effect
stringclasses 48
values | original_source_type
stringlengths 0
23k
| opens_and_abbrevs
listlengths 2
92
| isa_cross_project_example
bool 1
class | source_definition
stringlengths 9
57.9k
| partial_definition
stringlengths 7
23.3k
| is_div
bool 2
classes | is_type
null | is_proof
bool 2
classes | completed_definiton
stringlengths 1
250k
| dependencies
dict | effect_flags
sequencelengths 0
2
| ideal_premises
sequencelengths 0
236
| mutual_with
sequencelengths 0
11
| file_context
stringlengths 0
407k
| interleaved
bool 1
class | is_simply_typed
bool 2
classes | file_name
stringlengths 5
48
| vconfig
dict | is_simple_lemma
null | source_type
stringlengths 10
23k
| proof_features
sequencelengths 0
1
| name
stringlengths 8
95
| source
dict | verbose_type
stringlengths 1
7.42k
| source_range
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Prims.Tot | val lift_serializer
(#k: parser_kind)
(#t: Type)
(#f: (unit -> GTot (parser k t)))
(s: (unit -> GTot (serializer (f ()))))
: Tot (serializer #k #t (lift_parser f)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let lift_serializer
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Tot (serializer #k #t (lift_parser f))
= lift_serializer_correct #k #t #f s;
lift_serializer' #k #t #f s | val lift_serializer
(#k: parser_kind)
(#t: Type)
(#f: (unit -> GTot (parser k t)))
(s: (unit -> GTot (serializer (f ()))))
: Tot (serializer #k #t (lift_parser f))
let lift_serializer
(#k: parser_kind)
(#t: Type)
(#f: (unit -> GTot (parser k t)))
(s: (unit -> GTot (serializer (f ()))))
: Tot (serializer #k #t (lift_parser f)) = | false | null | false | lift_serializer_correct #k #t #f s;
lift_serializer' #k #t #f s | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"Prims.unit",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.Combinators.lift_serializer'",
"LowParse.Spec.Combinators.lift_serializer_correct",
"LowParse.Spec.Combinators.lift_parser"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2)
val serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
: Tot (serializer (nondep_then p1 p2))
val serialize_nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input: t1 * t2)
: Lemma
(serialize (serialize_nondep_then s1 s2) input == bare_serialize_nondep_then p1 s1 p2 s2 input)
val length_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input1: t1)
(input2: t2)
: Lemma
(Seq.length (serialize (serialize_nondep_then s1 s2) (input1, input2)) == Seq.length (serialize s1 input1) + Seq.length (serialize s2 input2))
val serialize_nondep_then_upd_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s 0 (serialize s1 y)
))
val serialize_nondep_then_upd_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s i' s'
))
val serialize_nondep_then_upd_bw_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s len2 (serialize s1 y)
))
#reset-options "--z3refresh --z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val serialize_nondep_then_upd_bw_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_bw_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s (len2 + i') s'
))
val serialize_nondep_then_upd_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (Seq.length s - Seq.length (serialize s2 y)) (serialize s2 y)
))
val serialize_nondep_then_upd_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
l1 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (l1 + i') s'
))
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y)
))
= serialize_nondep_then_upd_right s1 s2 x y
let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_bw_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s'
))
= let s2' = serialize s2 (snd x) in
let j' = Seq.length s2' - i' - Seq.length s' in
assert (j' + Seq.length s' <= Seq.length s2');
assert (serialize s2 y == seq_upd_seq s2' j' s');
let s = serialize (serialize_nondep_then s1 s2) x in
serialize_nondep_then_upd_right_chain s1 s2 x y j' s';
assert (Seq.length (serialize s1 (fst x)) + j' == Seq.length s - i' - Seq.length s');
()
#reset-options "--z3rlimit 32 --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Apply a total transformation on parsed data *)
let parse_strengthen_prf
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
: Tot Type
= (xbytes: bytes) ->
(consumed: consumed_length xbytes) ->
(x: t1) ->
Lemma
(requires (parse p1 xbytes == Some (x, consumed)))
(ensures (p2 x))
let bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1 { p2 x } ))
= fun (xbytes: bytes) ->
match parse p1 xbytes with
| Some (x, consumed) ->
prf xbytes consumed x;
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
let bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf))
= let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . no_lookahead_on p1 b1 b2 ==> no_lookahead_on p' b1 b2)
let bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . injective_precond p' b1 b2 ==> injective_precond p1 b1 b2);
assert (forall (b1 b2: bytes) . injective_postcond p1 b1 b2 ==> injective_postcond p' b1 b2)
let bare_parse_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf) /\
parser_kind_prop k (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
bare_parse_strengthen_no_lookahead p1 p2 prf;
bare_parse_strengthen_injective p1 p2 prf;
parser_kind_prop_equiv k (bare_parse_strengthen p1 p2 prf);
()
let parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser k (x: t1 { p2 x } ))
= bare_parse_strengthen_correct p1 p2 prf;
bare_parse_strengthen p1 p2 prf
let serialize_strengthen'
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: GTot bytes
= serialize s input
let serialize_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: Lemma
(let output = serialize_strengthen' p2 prf s input in
parse (parse_strengthen p1 p2 prf) output == Some (input, Seq.length output))
= ()
let serialize_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
: Tot (serializer (parse_strengthen p1 p2 prf))
= Classical.forall_intro (serialize_strengthen_correct p2 prf s);
serialize_strengthen' p2 prf s
let compose (#t1 #t2 #t3: Type) (f1: t1 -> GTot t2) (f2: t2 -> GTot t3) (x: t1) : GTot t3 =
let y1 = f1 x in
f2 y1
val make_total_constant_size_parser_compose
(sz: nat)
(t1 t2: Type)
(f1: ((s: bytes {Seq.length s == sz}) -> GTot t1))
(g2: t1 -> GTot t2)
: Lemma
(requires (
make_total_constant_size_parser_precond sz t1 f1 /\
(forall x x' . g2 x == g2 x' ==> x == x')
))
(ensures (
make_total_constant_size_parser_precond sz t1 f1 /\
make_total_constant_size_parser_precond sz t2 (f1 `compose` g2) /\
(forall x x' . {:pattern (g2 x); (g2 x')} g2 x == g2 x' ==> x == x') /\
(forall input . {:pattern (parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input)} parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input == parse (make_total_constant_size_parser sz t1 f1 `parse_synth` g2) input)
))
(** Tot vs. Ghost *)
unfold
let lift_parser'
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (bare_parser t)
= fun (input: bytes) -> parse (f ()) input
let lift_parser_correct
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Lemma
(parser_kind_prop k (lift_parser' f))
= parser_kind_prop_ext k (f ()) (lift_parser' f)
let lift_parser
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (parser k t)
= lift_parser_correct f;
lift_parser' f
unfold
let lift_serializer'
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Tot (bare_serializer t)
= fun (x: t) -> serialize (s ()) x
let lift_serializer_correct
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Lemma
(serializer_correct (lift_parser f) (lift_serializer' s))
= ()
let lift_serializer
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ()))) | false | false | LowParse.Spec.Combinators.fsti | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lift_serializer
(#k: parser_kind)
(#t: Type)
(#f: (unit -> GTot (parser k t)))
(s: (unit -> GTot (serializer (f ()))))
: Tot (serializer #k #t (lift_parser f)) | [] | LowParse.Spec.Combinators.lift_serializer | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | s: (_: Prims.unit -> Prims.GTot (LowParse.Spec.Base.serializer (f ())))
-> LowParse.Spec.Base.serializer (LowParse.Spec.Combinators.lift_parser f) | {
"end_col": 29,
"end_line": 1790,
"start_col": 2,
"start_line": 1789
} |
Prims.Tot | val parse_synth' (#k: parser_kind) (#t1 #t2: Type) (p1: parser k t1) (f2: (t1 -> GTot t2))
: Tot (bare_parser t2) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed) | val parse_synth' (#k: parser_kind) (#t1 #t2: Type) (p1: parser k t1) (f2: (t1 -> GTot t2))
: Tot (bare_parser t2)
let parse_synth' (#k: parser_kind) (#t1 #t2: Type) (p1: parser k t1) (f2: (t1 -> GTot t2))
: Tot (bare_parser t2) = | false | null | false | fun b ->
match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.bare_parser"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val parse_synth' (#k: parser_kind) (#t1 #t2: Type) (p1: parser k t1) (f2: (t1 -> GTot t2))
: Tot (bare_parser t2) | [] | LowParse.Spec.Combinators.parse_synth' | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p1: LowParse.Spec.Base.parser k t1 -> f2: (_: t1 -> Prims.GTot t2)
-> LowParse.Spec.Base.bare_parser t2 | {
"end_col": 49,
"end_line": 604,
"start_col": 2,
"start_line": 602
} |
Prims.Tot | val fail_serializer
(k: parser_kind{fail_parser_kind_precond k})
(t: Type)
(prf: (x: t -> Lemma False))
: Tot (serializer (fail_parser k t)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x) | val fail_serializer
(k: parser_kind{fail_parser_kind_precond k})
(t: Type)
(prf: (x: t -> Lemma False))
: Tot (serializer (fail_parser k t))
let fail_serializer
(k: parser_kind{fail_parser_kind_precond k})
(t: Type)
(prf: (x: t -> Lemma False))
: Tot (serializer (fail_parser k t)) = | false | null | false | mk_serializer (fail_parser k t)
(fun x ->
prf x;
false_elim ())
(fun x -> prf x) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Combinators.fail_parser_kind_precond",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_False",
"Prims.Nil",
"FStar.Pervasives.pattern",
"LowParse.Spec.Base.mk_serializer",
"LowParse.Spec.Combinators.fail_parser",
"FStar.Pervasives.false_elim",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.serializer"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False) | false | false | LowParse.Spec.Combinators.fsti | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fail_serializer
(k: parser_kind{fail_parser_kind_precond k})
(t: Type)
(prf: (x: t -> Lemma False))
: Tot (serializer (fail_parser k t)) | [] | LowParse.Spec.Combinators.fail_serializer | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
k: LowParse.Spec.Base.parser_kind{LowParse.Spec.Combinators.fail_parser_kind_precond k} ->
t: Type ->
prf: (x: t -> FStar.Pervasives.Lemma (ensures Prims.l_False))
-> LowParse.Spec.Base.serializer (LowParse.Spec.Combinators.fail_parser k t) | {
"end_col": 20,
"end_line": 258,
"start_col": 2,
"start_line": 255
} |
Prims.Tot | val synth_injective_synth_inverse_synth_inverse_recip
(#t1 #t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x) | val synth_injective_synth_inverse_synth_inverse_recip
(#t1 #t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
let synth_injective_synth_inverse_synth_inverse_recip
(#t1 #t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g)) = | false | null | true | assert (forall x. g (f (g x)) == g x) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"Prims.squash",
"Prims.l_and",
"LowParse.Spec.Combinators.synth_inverse",
"LowParse.Spec.Combinators.synth_injective",
"Prims._assert",
"Prims.l_Forall",
"Prims.eq2"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g)) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val synth_injective_synth_inverse_synth_inverse_recip
(#t1 #t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g)) | [] | LowParse.Spec.Combinators.synth_injective_synth_inverse_synth_inverse_recip | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
g: (_: t2 -> Prims.GTot t1) ->
f: (_: t1 -> Prims.GTot t2) ->
u176:
Prims.squash (LowParse.Spec.Combinators.synth_inverse g f /\
LowParse.Spec.Combinators.synth_injective g)
-> Prims.squash (LowParse.Spec.Combinators.synth_inverse f g) | {
"end_col": 40,
"end_line": 758,
"start_col": 2,
"start_line": 758
} |
Prims.Tot | val parse_tagged_union_payload
(#tag_t #data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(tg: tag_t)
: Tot (parser k data_t) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg) | val parse_tagged_union_payload
(#tag_t #data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(tg: tag_t)
: Tot (parser k data_t)
let parse_tagged_union_payload
(#tag_t #data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(tg: tag_t)
: Tot (parser k data_t) = | false | null | false | parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.refine_with_tag",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.Combinators.synth_tagged_union_data"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val parse_tagged_union_payload
(#tag_t #data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(tg: tag_t)
: Tot (parser k data_t) | [] | LowParse.Spec.Combinators.parse_tagged_union_payload | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
tag_of_data: (_: data_t -> Prims.GTot tag_t) ->
p: (t: tag_t -> LowParse.Spec.Base.parser k (LowParse.Spec.Base.refine_with_tag tag_of_data t)) ->
tg: tag_t
-> LowParse.Spec.Base.parser k data_t | {
"end_col": 98,
"end_line": 912,
"start_col": 2,
"start_line": 912
} |
FStar.Pervasives.Lemma | val and_then_injective (#t #t': Type) (p: bare_parser t) (p': (t -> Tot (bare_parser t')))
: Lemma
(requires (injective p /\ (forall (x: t). injective (p' x)) /\ and_then_cases_injective p'))
(ensures (injective (and_then_bare p p'))) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x)) | val and_then_injective (#t #t': Type) (p: bare_parser t) (p': (t -> Tot (bare_parser t')))
: Lemma
(requires (injective p /\ (forall (x: t). injective (p' x)) /\ and_then_cases_injective p'))
(ensures (injective (and_then_bare p p')))
let and_then_injective (#t #t': Type) (p: bare_parser t) (p': (t -> Tot (bare_parser t')))
: Lemma
(requires (injective p /\ (forall (x: t). injective (p' x)) /\ and_then_cases_injective p'))
(ensures (injective (and_then_bare p p'))) = | false | null | true | let ps = and_then_bare p p' in
let f (b1 b2: bytes)
: Lemma (requires (injective_precond ps b1 b2)) (ensures (injective_postcond ps b1 b2)) =
let Some (v1, len1) = p b1 in
let Some (v2, len2) = p b2 in
let b1':bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2':bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let Some (_, len1') = (p' v1) b1' in
let Some (_, len2') = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x)) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.bare_parser",
"FStar.Classical.forall_intro_2",
"LowParse.Bytes.bytes",
"Prims.l_imp",
"LowParse.Spec.Base.injective_precond",
"LowParse.Spec.Base.injective_postcond",
"FStar.Classical.move_requires",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"LowParse.Spec.Base.consumed_length",
"Prims._assert",
"FStar.Seq.Properties.lemma_split",
"LowParse.Bytes.byte",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Prims.eq2",
"Prims.nat",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.injective",
"LowParse.Spec.Combinators.and_then_cases_injective_precond",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"FStar.Seq.Base.length",
"LowParse.Spec.Combinators.and_then_bare",
"Prims.l_and",
"Prims.l_Forall",
"LowParse.Spec.Combinators.and_then_cases_injective"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') | false | false | LowParse.Spec.Combinators.fsti | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val and_then_injective (#t #t': Type) (p: bare_parser t) (p': (t -> Tot (bare_parser t')))
: Lemma
(requires (injective p /\ (forall (x: t). injective (p' x)) /\ and_then_cases_injective p'))
(ensures (injective (and_then_bare p p'))) | [] | LowParse.Spec.Combinators.and_then_injective | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: LowParse.Spec.Base.bare_parser t -> p': (_: t -> LowParse.Spec.Base.bare_parser t')
-> FStar.Pervasives.Lemma
(requires
LowParse.Spec.Base.injective p /\ (forall (x: t). LowParse.Spec.Base.injective (p' x)) /\
LowParse.Spec.Combinators.and_then_cases_injective p')
(ensures LowParse.Spec.Base.injective (LowParse.Spec.Combinators.and_then_bare p p')) | {
"end_col": 67,
"end_line": 367,
"start_col": 1,
"start_line": 341
} |
Prims.Pure | val tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> Tot t))
: Pure (tot_parser (total_constant_size_parser_kind sz) t)
(requires (make_total_constant_size_parser_precond sz t f))
(ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p | val tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> Tot t))
: Pure (tot_parser (total_constant_size_parser_kind sz) t)
(requires (make_total_constant_size_parser_precond sz t f))
(ensures (fun _ -> True))
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> Tot t))
: Pure (tot_parser (total_constant_size_parser_kind sz) t)
(requires (make_total_constant_size_parser_precond sz t f))
(ensures (fun _ -> True)) = | false | null | false | let p:tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [] | [
"Prims.nat",
"LowParse.Bytes.bytes",
"Prims.eq2",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"Prims.unit",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"LowParse.Spec.Base.total_constant_size_parser_kind",
"LowParse.Spec.Base.tot_bare_parser",
"LowParse.Spec.Combinators.tot_make_constant_size_parser",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.tot_parser",
"LowParse.Spec.Combinators.make_total_constant_size_parser_precond",
"Prims.l_True"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
)) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> Tot t))
: Pure (tot_parser (total_constant_size_parser_kind sz) t)
(requires (make_total_constant_size_parser_precond sz t f))
(ensures (fun _ -> True)) | [] | LowParse.Spec.Combinators.tot_make_total_constant_size_parser | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | sz: Prims.nat -> t: Type -> f: (s: LowParse.Bytes.bytes{FStar.Seq.Base.length s == sz} -> t)
-> Prims.Pure
(LowParse.Spec.Base.tot_parser (LowParse.Spec.Base.total_constant_size_parser_kind sz) t) | {
"end_col": 3,
"end_line": 183,
"start_col": 1,
"start_line": 181
} |
Prims.Tot | val bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1 -> parser k2 (t2 x)))
: Tot (bare_parser (dtuple2 t1 t2)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None | val bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1 -> parser k2 (t2 x)))
: Tot (bare_parser (dtuple2 t1 t2))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1 -> parser k2 (t2 x)))
: Tot (bare_parser (dtuple2 t1 t2)) = | false | null | false | fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
(match parse (p2 x1) b' with
| Some (x2, consumed2) -> Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None)
| _ -> None | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Base.consumed_length",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"Prims.dtuple2",
"FStar.Pervasives.Native.Mktuple2",
"Prims.Mkdtuple2",
"Prims.op_Addition",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.None",
"FStar.Seq.Base.seq",
"LowParse.Bytes.byte",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.length",
"LowParse.Spec.Base.bare_parser"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x)) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1 -> parser k2 (t2 x)))
: Tot (bare_parser (dtuple2 t1 t2)) | [] | LowParse.Spec.Combinators.bare_parse_dtuple2 | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p1: LowParse.Spec.Base.parser k1 t1 -> p2: (x: t1 -> LowParse.Spec.Base.parser k2 (t2 x))
-> LowParse.Spec.Base.bare_parser (Prims.dtuple2 t1 t2) | {
"end_col": 13,
"end_line": 1256,
"start_col": 2,
"start_line": 1247
} |
Prims.Pure | val tot_parse_tagged_union_payload
(#tag_t #data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (tot_parser k (refine_with_tag tag_of_data t))))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures
(fun y -> forall x. parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg) | val tot_parse_tagged_union_payload
(#tag_t #data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (tot_parser k (refine_with_tag tag_of_data t))))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures
(fun y -> forall x. parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x))
let tot_parse_tagged_union_payload
(#tag_t #data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (tot_parser k (refine_with_tag tag_of_data t))))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures
(fun y -> forall x. parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x)) = | false | null | false | tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.tot_parser",
"LowParse.Spec.Base.refine_with_tag",
"LowParse.Spec.Combinators.tot_parse_synth",
"LowParse.Spec.Combinators.synth_tagged_union_data",
"Prims.l_True",
"Prims.l_Forall",
"LowParse.Bytes.bytes",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Combinators.parse_tagged_union_payload"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val tot_parse_tagged_union_payload
(#tag_t #data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (tot_parser k (refine_with_tag tag_of_data t))))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures
(fun y -> forall x. parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x)) | [] | LowParse.Spec.Combinators.tot_parse_tagged_union_payload | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
tag_of_data: (_: data_t -> tag_t) ->
p:
(t: tag_t
-> LowParse.Spec.Base.tot_parser k (LowParse.Spec.Base.refine_with_tag tag_of_data t)) ->
tg: tag_t
-> Prims.Pure (LowParse.Spec.Base.tot_parser k data_t) | {
"end_col": 102,
"end_line": 1015,
"start_col": 2,
"start_line": 1015
} |
Prims.Tot | val parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1 -> parser k2 (t2 x)))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x)) | val parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1 -> parser k2 (t2 x)))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1 -> parser k2 (t2 x)))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2)) = | false | null | false | parse_tagged_union p1 dfst (fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x)) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Combinators.parse_tagged_union",
"Prims.dtuple2",
"FStar.Pervasives.dfst",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.Base.refine_with_tag",
"LowParse.Spec.Combinators.synth_dtuple2",
"LowParse.Spec.Combinators.and_then_kind"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x)) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1 -> parser k2 (t2 x)))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2)) | [] | LowParse.Spec.Combinators.parse_dtuple2 | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p1: LowParse.Spec.Base.parser k1 t1 -> p2: (x: t1 -> LowParse.Spec.Base.parser k2 (t2 x))
-> LowParse.Spec.Base.parser (LowParse.Spec.Combinators.and_then_kind k1 k2) (Prims.dtuple2 t1 t2) | {
"end_col": 57,
"end_line": 1197,
"start_col": 2,
"start_line": 1194
} |
Prims.Pure | val serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t -> Tot (tot_parser k (refine_with_tag tag_of_data t))))
(s: (t: tag_t -> Tot (serializer #k (p t))))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_ | val serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t -> Tot (tot_parser k (refine_with_tag tag_of_data t))))
(s: (t: tag_t -> Tot (serializer #k (p t))))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t -> Tot (tot_parser k (refine_with_tag tag_of_data t))))
(s: (t: tag_t -> Tot (serializer #k (p t))))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True)) = | false | null | false | serialize_ext _ (serialize_tagged_union st tag_of_data s) _ | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.tot_parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.Base.refine_with_tag",
"LowParse.Spec.Base.serialize_ext",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.parse_tagged_union",
"LowParse.Spec.Combinators.serialize_tagged_union",
"LowParse.Spec.Combinators.tot_parse_tagged_union",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"Prims.l_True"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong)) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t -> Tot (tot_parser k (refine_with_tag tag_of_data t))))
(s: (t: tag_t -> Tot (serializer #k (p t))))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True)) | [] | LowParse.Spec.Combinators.serialize_tot_tagged_union | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
st: LowParse.Spec.Base.serializer pt ->
tag_of_data: (_: data_t -> tag_t) ->
s: (t: tag_t -> LowParse.Spec.Base.serializer (p t))
-> Prims.Pure
(LowParse.Spec.Base.serializer (LowParse.Spec.Combinators.tot_parse_tagged_union pt
tag_of_data
p)) | {
"end_col": 5,
"end_line": 1173,
"start_col": 2,
"start_line": 1171
} |
Prims.Tot | val synth_dtuple2 (#t1: Type) (#t2: (t1 -> Type)) (x: t1) (y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |) | val synth_dtuple2 (#t1: Type) (#t2: (t1 -> Type)) (x: t1) (y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
let synth_dtuple2 (#t1: Type) (#t2: (t1 -> Type)) (x: t1) (y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x) = | false | null | false | (| x, y |) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"Prims.Mkdtuple2",
"LowParse.Spec.Base.refine_with_tag",
"Prims.dtuple2",
"FStar.Pervasives.dfst"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val synth_dtuple2 (#t1: Type) (#t2: (t1 -> Type)) (x: t1) (y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x) | [] | LowParse.Spec.Combinators.synth_dtuple2 | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: t1 -> y: t2 x -> LowParse.Spec.Base.refine_with_tag FStar.Pervasives.dfst x | {
"end_col": 12,
"end_line": 1184,
"start_col": 2,
"start_line": 1184
} |
Prims.Pure | val make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot t))
: Pure (parser (total_constant_size_parser_kind sz) t)
(requires (make_total_constant_size_parser_precond sz t f))
(ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p | val make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot t))
: Pure (parser (total_constant_size_parser_kind sz) t)
(requires (make_total_constant_size_parser_precond sz t f))
(ensures (fun _ -> True))
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot t))
: Pure (parser (total_constant_size_parser_kind sz) t)
(requires (make_total_constant_size_parser_precond sz t f))
(ensures (fun _ -> True)) = | false | null | false | let p:bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [] | [
"Prims.nat",
"LowParse.Bytes.bytes",
"Prims.eq2",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"Prims.unit",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"LowParse.Spec.Base.total_constant_size_parser_kind",
"LowParse.Spec.Base.bare_parser",
"LowParse.Spec.Combinators.make_constant_size_parser",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Combinators.make_total_constant_size_parser_precond",
"Prims.l_True"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
)) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot t))
: Pure (parser (total_constant_size_parser_kind sz) t)
(requires (make_total_constant_size_parser_precond sz t f))
(ensures (fun _ -> True)) | [] | LowParse.Spec.Combinators.make_total_constant_size_parser | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
sz: Prims.nat ->
t: Type ->
f: (s: LowParse.Bytes.bytes{FStar.Seq.Base.length s == sz} -> Prims.GTot t)
-> Prims.Pure
(LowParse.Spec.Base.parser (LowParse.Spec.Base.total_constant_size_parser_kind sz) t) | {
"end_col": 3,
"end_line": 166,
"start_col": 1,
"start_line": 164
} |
FStar.Pervasives.Lemma | val tot_parse_synth_eq
(#k: parser_kind)
(#t1 #t2: Type)
(p1: tot_parser k t1)
(f2: (t1 -> Tot t2))
(b: bytes)
: Lemma (requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b | val tot_parse_synth_eq
(#k: parser_kind)
(#t1 #t2: Type)
(p1: tot_parser k t1)
(f2: (t1 -> Tot t2))
(b: bytes)
: Lemma (requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1 #t2: Type)
(p1: tot_parser k t1)
(f2: (t1 -> Tot t2))
(b: bytes)
: Lemma (requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b)) = | false | null | true | parse_synth_eq #k p1 f2 b | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.tot_parser",
"LowParse.Bytes.bytes",
"LowParse.Spec.Combinators.parse_synth_eq",
"Prims.unit",
"LowParse.Spec.Combinators.synth_injective",
"Prims.squash",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Combinators.tot_parse_synth",
"LowParse.Spec.Combinators.parse_synth'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2)) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val tot_parse_synth_eq
(#k: parser_kind)
(#t1 #t2: Type)
(p1: tot_parser k t1)
(f2: (t1 -> Tot t2))
(b: bytes)
: Lemma (requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b)) | [] | LowParse.Spec.Combinators.tot_parse_synth_eq | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p1: LowParse.Spec.Base.tot_parser k t1 -> f2: (_: t1 -> t2) -> b: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma (requires LowParse.Spec.Combinators.synth_injective f2)
(ensures
LowParse.Spec.Base.parse (LowParse.Spec.Combinators.tot_parse_synth p1 f2) b ==
LowParse.Spec.Combinators.parse_synth' p1 f2 b) | {
"end_col": 27,
"end_line": 665,
"start_col": 2,
"start_line": 665
} |
Prims.Tot | val serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1 -> parser k2 (t2 x)))
(s2: (x: t1 -> serializer (p2 x)))
(xy: dtuple2 t1 t2)
: Tot
(squash ((serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy ==
bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy))) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy | val serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1 -> parser k2 (t2 x)))
(s2: (x: t1 -> serializer (p2 x)))
(xy: dtuple2 t1 t2)
: Tot
(squash ((serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy ==
bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1 -> parser k2 (t2 x)))
(s2: (x: t1 -> serializer (p2 x)))
(xy: dtuple2 t1 t2)
: Tot
(squash ((serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy ==
bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy))) = | false | null | true | serialize_dtuple2_eq s1 s2 xy | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"Prims.dtuple2",
"LowParse.Spec.Combinators.serialize_dtuple2_eq",
"Prims.squash",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.serialize",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.parse_dtuple2",
"LowParse.Spec.Combinators.serialize_dtuple2",
"LowParse.Spec.Combinators.bare_serialize_dtuple2"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash ( | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1 -> parser k2 (t2 x)))
(s2: (x: t1 -> serializer (p2 x)))
(xy: dtuple2 t1 t2)
: Tot
(squash ((serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy ==
bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy))) | [] | LowParse.Spec.Combinators.serialize_dtuple2_eq' | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s1:
LowParse.Spec.Base.serializer p1
{ Mkparser_kind'?.parser_kind_subkind k1 ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } ->
s2: (x: t1 -> LowParse.Spec.Base.serializer (p2 x)) ->
xy: Prims.dtuple2 t1 t2
-> Prims.squash (LowParse.Spec.Base.serialize (LowParse.Spec.Combinators.serialize_dtuple2 s1 s2)
xy ==
LowParse.Spec.Combinators.bare_serialize_dtuple2 s1 s2 xy) | {
"end_col": 31,
"end_line": 1308,
"start_col": 2,
"start_line": 1308
} |
FStar.Pervasives.Lemma | val bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Lemma (injective (bare_parse_strengthen p1 p2 prf)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . injective_precond p' b1 b2 ==> injective_precond p1 b1 b2);
assert (forall (b1 b2: bytes) . injective_postcond p1 b1 b2 ==> injective_postcond p' b1 b2) | val bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Lemma (injective (bare_parse_strengthen p1 p2 prf))
let bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Lemma (injective (bare_parse_strengthen p1 p2 prf)) = | false | null | true | parser_kind_prop_equiv k p1;
let p':bare_parser (x: t1{p2 x}) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1: bytes) (b2: bytes). injective_precond p' b1 b2 ==> injective_precond p1 b1 b2);
assert (forall (b1: bytes) (b2: bytes). injective_postcond p1 b1 b2 ==> injective_postcond p' b1 b2) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Combinators.parse_strengthen_prf",
"Prims._assert",
"Prims.l_Forall",
"LowParse.Bytes.bytes",
"Prims.l_imp",
"LowParse.Spec.Base.injective_postcond",
"Prims.unit",
"LowParse.Spec.Base.injective_precond",
"LowParse.Spec.Base.bare_parser",
"LowParse.Spec.Combinators.bare_parse_strengthen",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"Prims.l_True",
"Prims.squash",
"LowParse.Spec.Base.injective",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2)
val serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
: Tot (serializer (nondep_then p1 p2))
val serialize_nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input: t1 * t2)
: Lemma
(serialize (serialize_nondep_then s1 s2) input == bare_serialize_nondep_then p1 s1 p2 s2 input)
val length_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input1: t1)
(input2: t2)
: Lemma
(Seq.length (serialize (serialize_nondep_then s1 s2) (input1, input2)) == Seq.length (serialize s1 input1) + Seq.length (serialize s2 input2))
val serialize_nondep_then_upd_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s 0 (serialize s1 y)
))
val serialize_nondep_then_upd_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s i' s'
))
val serialize_nondep_then_upd_bw_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s len2 (serialize s1 y)
))
#reset-options "--z3refresh --z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val serialize_nondep_then_upd_bw_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_bw_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s (len2 + i') s'
))
val serialize_nondep_then_upd_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (Seq.length s - Seq.length (serialize s2 y)) (serialize s2 y)
))
val serialize_nondep_then_upd_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
l1 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (l1 + i') s'
))
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y)
))
= serialize_nondep_then_upd_right s1 s2 x y
let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_bw_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s'
))
= let s2' = serialize s2 (snd x) in
let j' = Seq.length s2' - i' - Seq.length s' in
assert (j' + Seq.length s' <= Seq.length s2');
assert (serialize s2 y == seq_upd_seq s2' j' s');
let s = serialize (serialize_nondep_then s1 s2) x in
serialize_nondep_then_upd_right_chain s1 s2 x y j' s';
assert (Seq.length (serialize s1 (fst x)) + j' == Seq.length s - i' - Seq.length s');
()
#reset-options "--z3rlimit 32 --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Apply a total transformation on parsed data *)
let parse_strengthen_prf
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
: Tot Type
= (xbytes: bytes) ->
(consumed: consumed_length xbytes) ->
(x: t1) ->
Lemma
(requires (parse p1 xbytes == Some (x, consumed)))
(ensures (p2 x))
let bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1 { p2 x } ))
= fun (xbytes: bytes) ->
match parse p1 xbytes with
| Some (x, consumed) ->
prf xbytes consumed x;
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
let bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf))
= let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . no_lookahead_on p1 b1 b2 ==> no_lookahead_on p' b1 b2)
let bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma | false | false | LowParse.Spec.Combinators.fsti | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Lemma (injective (bare_parse_strengthen p1 p2 prf)) | [] | LowParse.Spec.Combinators.bare_parse_strengthen_injective | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p1: LowParse.Spec.Base.parser k t1 ->
p2: (_: t1 -> Prims.GTot Type0) ->
prf: LowParse.Spec.Combinators.parse_strengthen_prf p1 p2
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Base.injective (LowParse.Spec.Combinators.bare_parse_strengthen p1 p2 prf)) | {
"end_col": 94,
"end_line": 1656,
"start_col": 2,
"start_line": 1653
} |
Prims.Tot | val parse_filter_payload (#t: Type) (f: (t -> GTot bool)) (v: t)
: Tot (parser parse_filter_payload_kind (parse_filter_refine f)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let parse_filter_payload
(#t: Type)
(f: (t -> GTot bool))
(v: t)
: Tot (parser parse_filter_payload_kind (parse_filter_refine f))
= let p = lift_parser (fun () ->
if f v
then
let v' : (x: t { f x == true } ) = v in
weaken parse_filter_payload_kind (parse_ret v')
else fail_parser parse_filter_payload_kind (parse_filter_refine f)
)
in
parser_kind_prop_equiv parse_filter_payload_kind p;
p | val parse_filter_payload (#t: Type) (f: (t -> GTot bool)) (v: t)
: Tot (parser parse_filter_payload_kind (parse_filter_refine f))
let parse_filter_payload (#t: Type) (f: (t -> GTot bool)) (v: t)
: Tot (parser parse_filter_payload_kind (parse_filter_refine f)) = | false | null | false | let p =
lift_parser (fun () ->
if f v
then
let v':(x: t{f x == true}) = v in
weaken parse_filter_payload_kind (parse_ret v')
else fail_parser parse_filter_payload_kind (parse_filter_refine f))
in
parser_kind_prop_equiv parse_filter_payload_kind p;
p | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"Prims.bool",
"Prims.unit",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.Combinators.parse_filter_payload_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Combinators.lift_parser",
"LowParse.Spec.Base.weaken",
"LowParse.Spec.Combinators.parse_ret_kind",
"LowParse.Spec.Combinators.parse_ret",
"Prims.eq2",
"LowParse.Spec.Combinators.fail_parser"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2)
val serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
: Tot (serializer (nondep_then p1 p2))
val serialize_nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input: t1 * t2)
: Lemma
(serialize (serialize_nondep_then s1 s2) input == bare_serialize_nondep_then p1 s1 p2 s2 input)
val length_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input1: t1)
(input2: t2)
: Lemma
(Seq.length (serialize (serialize_nondep_then s1 s2) (input1, input2)) == Seq.length (serialize s1 input1) + Seq.length (serialize s2 input2))
val serialize_nondep_then_upd_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s 0 (serialize s1 y)
))
val serialize_nondep_then_upd_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s i' s'
))
val serialize_nondep_then_upd_bw_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s len2 (serialize s1 y)
))
#reset-options "--z3refresh --z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val serialize_nondep_then_upd_bw_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_bw_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s (len2 + i') s'
))
val serialize_nondep_then_upd_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (Seq.length s - Seq.length (serialize s2 y)) (serialize s2 y)
))
val serialize_nondep_then_upd_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
l1 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (l1 + i') s'
))
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y)
))
= serialize_nondep_then_upd_right s1 s2 x y
let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_bw_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s'
))
= let s2' = serialize s2 (snd x) in
let j' = Seq.length s2' - i' - Seq.length s' in
assert (j' + Seq.length s' <= Seq.length s2');
assert (serialize s2 y == seq_upd_seq s2' j' s');
let s = serialize (serialize_nondep_then s1 s2) x in
serialize_nondep_then_upd_right_chain s1 s2 x y j' s';
assert (Seq.length (serialize s1 (fst x)) + j' == Seq.length s - i' - Seq.length s');
()
#reset-options "--z3rlimit 32 --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Apply a total transformation on parsed data *)
let parse_strengthen_prf
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
: Tot Type
= (xbytes: bytes) ->
(consumed: consumed_length xbytes) ->
(x: t1) ->
Lemma
(requires (parse p1 xbytes == Some (x, consumed)))
(ensures (p2 x))
let bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1 { p2 x } ))
= fun (xbytes: bytes) ->
match parse p1 xbytes with
| Some (x, consumed) ->
prf xbytes consumed x;
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
let bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf))
= let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . no_lookahead_on p1 b1 b2 ==> no_lookahead_on p' b1 b2)
let bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . injective_precond p' b1 b2 ==> injective_precond p1 b1 b2);
assert (forall (b1 b2: bytes) . injective_postcond p1 b1 b2 ==> injective_postcond p' b1 b2)
let bare_parse_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf) /\
parser_kind_prop k (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
bare_parse_strengthen_no_lookahead p1 p2 prf;
bare_parse_strengthen_injective p1 p2 prf;
parser_kind_prop_equiv k (bare_parse_strengthen p1 p2 prf);
()
let parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser k (x: t1 { p2 x } ))
= bare_parse_strengthen_correct p1 p2 prf;
bare_parse_strengthen p1 p2 prf
let serialize_strengthen'
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: GTot bytes
= serialize s input
let serialize_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: Lemma
(let output = serialize_strengthen' p2 prf s input in
parse (parse_strengthen p1 p2 prf) output == Some (input, Seq.length output))
= ()
let serialize_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
: Tot (serializer (parse_strengthen p1 p2 prf))
= Classical.forall_intro (serialize_strengthen_correct p2 prf s);
serialize_strengthen' p2 prf s
let compose (#t1 #t2 #t3: Type) (f1: t1 -> GTot t2) (f2: t2 -> GTot t3) (x: t1) : GTot t3 =
let y1 = f1 x in
f2 y1
val make_total_constant_size_parser_compose
(sz: nat)
(t1 t2: Type)
(f1: ((s: bytes {Seq.length s == sz}) -> GTot t1))
(g2: t1 -> GTot t2)
: Lemma
(requires (
make_total_constant_size_parser_precond sz t1 f1 /\
(forall x x' . g2 x == g2 x' ==> x == x')
))
(ensures (
make_total_constant_size_parser_precond sz t1 f1 /\
make_total_constant_size_parser_precond sz t2 (f1 `compose` g2) /\
(forall x x' . {:pattern (g2 x); (g2 x')} g2 x == g2 x' ==> x == x') /\
(forall input . {:pattern (parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input)} parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input == parse (make_total_constant_size_parser sz t1 f1 `parse_synth` g2) input)
))
(** Tot vs. Ghost *)
unfold
let lift_parser'
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (bare_parser t)
= fun (input: bytes) -> parse (f ()) input
let lift_parser_correct
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Lemma
(parser_kind_prop k (lift_parser' f))
= parser_kind_prop_ext k (f ()) (lift_parser' f)
let lift_parser
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (parser k t)
= lift_parser_correct f;
lift_parser' f
unfold
let lift_serializer'
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Tot (bare_serializer t)
= fun (x: t) -> serialize (s ()) x
let lift_serializer_correct
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Lemma
(serializer_correct (lift_parser f) (lift_serializer' s))
= ()
let lift_serializer
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Tot (serializer #k #t (lift_parser f))
= lift_serializer_correct #k #t #f s;
lift_serializer' #k #t #f s
(** Refinements *)
// unfold
inline_for_extraction
let parse_filter_kind (k: parser_kind) : Tot parser_kind =
{
parser_kind_low = k.parser_kind_low;
parser_kind_high = k.parser_kind_high;
parser_kind_metadata =
begin match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
end;
parser_kind_subkind = k.parser_kind_subkind;
}
// unfold
let parse_filter_payload_kind : parser_kind =
strong_parser_kind 0 0 None
let parse_filter_refine (#t: Type) (f: (t -> GTot bool)) =
(x: t { f x == true } )
let parse_filter_payload
(#t: Type)
(f: (t -> GTot bool))
(v: t) | false | false | LowParse.Spec.Combinators.fsti | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_filter_payload (#t: Type) (f: (t -> GTot bool)) (v: t)
: Tot (parser parse_filter_payload_kind (parse_filter_refine f)) | [] | LowParse.Spec.Combinators.parse_filter_payload | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | f: (_: t -> Prims.GTot Prims.bool) -> v: t
-> LowParse.Spec.Base.parser LowParse.Spec.Combinators.parse_filter_payload_kind
(LowParse.Spec.Combinators.parse_filter_refine f) | {
"end_col": 3,
"end_line": 1829,
"start_col": 1,
"start_line": 1820
} |
FStar.Pervasives.Lemma | val seq_slice_append_l (#t: Type) (s1 s2: Seq.seq t)
: Lemma (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1) | val seq_slice_append_l (#t: Type) (s1 s2: Seq.seq t)
: Lemma (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
let seq_slice_append_l (#t: Type) (s1 s2: Seq.seq t)
: Lemma (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1) = | false | null | true | assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.append",
"FStar.Seq.Base.length",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val seq_slice_append_l (#t: Type) (s1 s2: Seq.seq t)
: Lemma (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1) | [] | LowParse.Spec.Combinators.seq_slice_append_l | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | s1: FStar.Seq.Base.seq t -> s2: FStar.Seq.Base.seq t
-> FStar.Pervasives.Lemma
(ensures FStar.Seq.Base.slice (FStar.Seq.Base.append s1 s2) 0 (FStar.Seq.Base.length s1) == s1) | {
"end_col": 72,
"end_line": 1072,
"start_col": 2,
"start_line": 1072
} |
FStar.Pervasives.Lemma | val serialize_synth_eq'
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(s1: serializer p1)
(g1: (t2 -> GTot t1))
(u: unit{synth_inverse f2 g1 /\ synth_injective f2})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma (ensures (y1 == y2)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x | val serialize_synth_eq'
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(s1: serializer p1)
(g1: (t2 -> GTot t1))
(u: unit{synth_inverse f2 g1 /\ synth_injective f2})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma (ensures (y1 == y2))
let serialize_synth_eq'
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(s1: serializer p1)
(g1: (t2 -> GTot t1))
(u: unit{synth_inverse f2 g1 /\ synth_injective f2})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma (ensures (y1 == y2)) = | false | null | true | serialize_synth_eq p1 f2 s1 g1 u x | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.unit",
"Prims.l_and",
"LowParse.Spec.Combinators.synth_inverse",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.Bytes.bytes",
"Prims.squash",
"Prims.eq2",
"LowParse.Spec.Base.serialize",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.Combinators.serialize_synth",
"LowParse.Spec.Combinators.serialize_synth_eq",
"Prims.l_True",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val serialize_synth_eq'
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(s1: serializer p1)
(g1: (t2 -> GTot t1))
(u: unit{synth_inverse f2 g1 /\ synth_injective f2})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma (ensures (y1 == y2)) | [] | LowParse.Spec.Combinators.serialize_synth_eq' | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p1: LowParse.Spec.Base.parser k t1 ->
f2: (_: t1 -> Prims.GTot t2) ->
s1: LowParse.Spec.Base.serializer p1 ->
g1: (_: t2 -> Prims.GTot t1) ->
u192:
u202:
Prims.unit
{ LowParse.Spec.Combinators.synth_inverse f2 g1 /\
LowParse.Spec.Combinators.synth_injective f2 } ->
x: t2 ->
y1: LowParse.Bytes.bytes ->
q1:
Prims.squash (y1 ==
LowParse.Spec.Base.serialize (LowParse.Spec.Combinators.serialize_synth p1 f2 s1 g1 u192)
x) ->
y2: LowParse.Bytes.bytes ->
q2: Prims.squash (y2 == LowParse.Spec.Base.serialize s1 (g1 x))
-> FStar.Pervasives.Lemma (ensures y1 == y2) | {
"end_col": 36,
"end_line": 809,
"start_col": 2,
"start_line": 809
} |
Prims.Tot | val serialize_weaken
(#k: parser_kind)
(#t: Type)
(k': parser_kind)
(#p: parser k t)
(s: serializer p {k' `is_weaker_than` k})
: Tot (serializer (weaken k' p)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let serialize_weaken
(#k: parser_kind)
(#t: Type)
(k' : parser_kind)
(#p: parser k t)
(s: serializer p { k' `is_weaker_than` k })
: Tot (serializer (weaken k' p))
= serialize_ext _ s (weaken k' p) | val serialize_weaken
(#k: parser_kind)
(#t: Type)
(k': parser_kind)
(#p: parser k t)
(s: serializer p {k' `is_weaker_than` k})
: Tot (serializer (weaken k' p))
let serialize_weaken
(#k: parser_kind)
(#t: Type)
(k': parser_kind)
(#p: parser k t)
(s: serializer p {k' `is_weaker_than` k})
: Tot (serializer (weaken k' p)) = | false | null | false | serialize_ext _ s (weaken k' p) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.Base.is_weaker_than",
"LowParse.Spec.Base.serialize_ext",
"LowParse.Spec.Base.weaken"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2)
val serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
: Tot (serializer (nondep_then p1 p2))
val serialize_nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input: t1 * t2)
: Lemma
(serialize (serialize_nondep_then s1 s2) input == bare_serialize_nondep_then p1 s1 p2 s2 input)
val length_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input1: t1)
(input2: t2)
: Lemma
(Seq.length (serialize (serialize_nondep_then s1 s2) (input1, input2)) == Seq.length (serialize s1 input1) + Seq.length (serialize s2 input2))
val serialize_nondep_then_upd_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s 0 (serialize s1 y)
))
val serialize_nondep_then_upd_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s i' s'
))
val serialize_nondep_then_upd_bw_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s len2 (serialize s1 y)
))
#reset-options "--z3refresh --z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val serialize_nondep_then_upd_bw_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_bw_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s (len2 + i') s'
))
val serialize_nondep_then_upd_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (Seq.length s - Seq.length (serialize s2 y)) (serialize s2 y)
))
val serialize_nondep_then_upd_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
l1 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (l1 + i') s'
))
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y)
))
= serialize_nondep_then_upd_right s1 s2 x y
let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_bw_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s'
))
= let s2' = serialize s2 (snd x) in
let j' = Seq.length s2' - i' - Seq.length s' in
assert (j' + Seq.length s' <= Seq.length s2');
assert (serialize s2 y == seq_upd_seq s2' j' s');
let s = serialize (serialize_nondep_then s1 s2) x in
serialize_nondep_then_upd_right_chain s1 s2 x y j' s';
assert (Seq.length (serialize s1 (fst x)) + j' == Seq.length s - i' - Seq.length s');
()
#reset-options "--z3rlimit 32 --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Apply a total transformation on parsed data *)
let parse_strengthen_prf
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
: Tot Type
= (xbytes: bytes) ->
(consumed: consumed_length xbytes) ->
(x: t1) ->
Lemma
(requires (parse p1 xbytes == Some (x, consumed)))
(ensures (p2 x))
let bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1 { p2 x } ))
= fun (xbytes: bytes) ->
match parse p1 xbytes with
| Some (x, consumed) ->
prf xbytes consumed x;
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
let bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf))
= let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . no_lookahead_on p1 b1 b2 ==> no_lookahead_on p' b1 b2)
let bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . injective_precond p' b1 b2 ==> injective_precond p1 b1 b2);
assert (forall (b1 b2: bytes) . injective_postcond p1 b1 b2 ==> injective_postcond p' b1 b2)
let bare_parse_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf) /\
parser_kind_prop k (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
bare_parse_strengthen_no_lookahead p1 p2 prf;
bare_parse_strengthen_injective p1 p2 prf;
parser_kind_prop_equiv k (bare_parse_strengthen p1 p2 prf);
()
let parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser k (x: t1 { p2 x } ))
= bare_parse_strengthen_correct p1 p2 prf;
bare_parse_strengthen p1 p2 prf
let serialize_strengthen'
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: GTot bytes
= serialize s input
let serialize_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: Lemma
(let output = serialize_strengthen' p2 prf s input in
parse (parse_strengthen p1 p2 prf) output == Some (input, Seq.length output))
= ()
let serialize_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
: Tot (serializer (parse_strengthen p1 p2 prf))
= Classical.forall_intro (serialize_strengthen_correct p2 prf s);
serialize_strengthen' p2 prf s
let compose (#t1 #t2 #t3: Type) (f1: t1 -> GTot t2) (f2: t2 -> GTot t3) (x: t1) : GTot t3 =
let y1 = f1 x in
f2 y1
val make_total_constant_size_parser_compose
(sz: nat)
(t1 t2: Type)
(f1: ((s: bytes {Seq.length s == sz}) -> GTot t1))
(g2: t1 -> GTot t2)
: Lemma
(requires (
make_total_constant_size_parser_precond sz t1 f1 /\
(forall x x' . g2 x == g2 x' ==> x == x')
))
(ensures (
make_total_constant_size_parser_precond sz t1 f1 /\
make_total_constant_size_parser_precond sz t2 (f1 `compose` g2) /\
(forall x x' . {:pattern (g2 x); (g2 x')} g2 x == g2 x' ==> x == x') /\
(forall input . {:pattern (parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input)} parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input == parse (make_total_constant_size_parser sz t1 f1 `parse_synth` g2) input)
))
(** Tot vs. Ghost *)
unfold
let lift_parser'
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (bare_parser t)
= fun (input: bytes) -> parse (f ()) input
let lift_parser_correct
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Lemma
(parser_kind_prop k (lift_parser' f))
= parser_kind_prop_ext k (f ()) (lift_parser' f)
let lift_parser
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (parser k t)
= lift_parser_correct f;
lift_parser' f
unfold
let lift_serializer'
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Tot (bare_serializer t)
= fun (x: t) -> serialize (s ()) x
let lift_serializer_correct
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Lemma
(serializer_correct (lift_parser f) (lift_serializer' s))
= ()
let lift_serializer
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Tot (serializer #k #t (lift_parser f))
= lift_serializer_correct #k #t #f s;
lift_serializer' #k #t #f s
(** Refinements *)
// unfold
inline_for_extraction
let parse_filter_kind (k: parser_kind) : Tot parser_kind =
{
parser_kind_low = k.parser_kind_low;
parser_kind_high = k.parser_kind_high;
parser_kind_metadata =
begin match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
end;
parser_kind_subkind = k.parser_kind_subkind;
}
// unfold
let parse_filter_payload_kind : parser_kind =
strong_parser_kind 0 0 None
let parse_filter_refine (#t: Type) (f: (t -> GTot bool)) =
(x: t { f x == true } )
let parse_filter_payload
(#t: Type)
(f: (t -> GTot bool))
(v: t)
: Tot (parser parse_filter_payload_kind (parse_filter_refine f))
= let p = lift_parser (fun () ->
if f v
then
let v' : (x: t { f x == true } ) = v in
weaken parse_filter_payload_kind (parse_ret v')
else fail_parser parse_filter_payload_kind (parse_filter_refine f)
)
in
parser_kind_prop_equiv parse_filter_payload_kind p;
p
val parse_filter
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
: Tot (parser (parse_filter_kind k) (parse_filter_refine f))
val parse_filter_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: bytes)
: Lemma
(parse (parse_filter p f) input == (match parse p input with
| None -> None
| Some (x, consumed) ->
if f x
then Some (x, consumed)
else None
))
val tot_parse_filter
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(f: (t -> Tot bool))
: Pure (tot_parser (parse_filter_kind k) (parse_filter_refine f))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_filter #k p f) x
))
let tot_parse_filter_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(f: (t -> Tot bool))
(input: bytes)
: Lemma
(parse (tot_parse_filter p f) input == (match parse p input with
| None -> None
| Some (x, consumed) ->
if f x
then Some (x, consumed)
else None
))
= parse_filter_eq #k p f input
let serialize_filter'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(f: (t -> GTot bool))
: Tot (bare_serializer (x: t { f x == true } ))
= fun (input: t { f input == true } ) -> s input
val serialize_filter_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(f: (t -> GTot bool))
: Lemma
(serializer_correct (parse_filter p f) (serialize_filter' s f))
let serialize_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(f: (t -> GTot bool))
: Tot (serializer (parse_filter p f))
= serialize_filter_correct s f;
serialize_filter' s f
let serialize_tot_filter
(#k: parser_kind)
(#t: Type)
(#p: tot_parser k t)
(s: serializer #k p)
(f: (t -> Tot bool))
: Tot (serializer (tot_parse_filter p f))
= serialize_ext #(parse_filter_kind k) _ (serialize_filter s f) #(parse_filter_kind k) _
let serialize_weaken
(#k: parser_kind)
(#t: Type)
(k' : parser_kind)
(#p: parser k t)
(s: serializer p { k' `is_weaker_than` k }) | false | false | LowParse.Spec.Combinators.fsti | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_weaken
(#k: parser_kind)
(#t: Type)
(k': parser_kind)
(#p: parser k t)
(s: serializer p {k' `is_weaker_than` k})
: Tot (serializer (weaken k' p)) | [] | LowParse.Spec.Combinators.serialize_weaken | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
k': LowParse.Spec.Base.parser_kind ->
s: LowParse.Spec.Base.serializer p {LowParse.Spec.Base.is_weaker_than k' k}
-> LowParse.Spec.Base.serializer (LowParse.Spec.Base.weaken k' p) | {
"end_col": 33,
"end_line": 1924,
"start_col": 2,
"start_line": 1924
} |
FStar.Pervasives.Lemma | val seq_slice_append_r (#t: Type) (s1 s2: Seq.seq t)
: Lemma (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2) | val seq_slice_append_r (#t: Type) (s1 s2: Seq.seq t)
: Lemma (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
let seq_slice_append_r (#t: Type) (s1 s2: Seq.seq t)
: Lemma (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2) = | false | null | true | assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.append",
"FStar.Seq.Base.length",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val seq_slice_append_r (#t: Type) (s1 s2: Seq.seq t)
: Lemma (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2) | [] | LowParse.Spec.Combinators.seq_slice_append_r | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | s1: FStar.Seq.Base.seq t -> s2: FStar.Seq.Base.seq t
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice (FStar.Seq.Base.append s1 s2)
(FStar.Seq.Base.length s1)
(FStar.Seq.Base.length (FStar.Seq.Base.append s1 s2)) ==
s2) | {
"end_col": 102,
"end_line": 1079,
"start_col": 2,
"start_line": 1079
} |
FStar.Pervasives.Lemma | val and_then_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(#k': parser_kind)
(#t': Type)
(p': (t -> Tot (parser k' t')))
: Lemma (requires (and_then_cases_injective p'))
(ensures
(injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p'))) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p' | val and_then_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(#k': parser_kind)
(#t': Type)
(p': (t -> Tot (parser k' t')))
: Lemma (requires (and_then_cases_injective p'))
(ensures
(injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')))
let and_then_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(#k': parser_kind)
(#t': Type)
(p': (t -> Tot (parser k' t')))
: Lemma (requires (and_then_cases_injective p'))
(ensures
(injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p'))) = | false | null | true | parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p' | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Combinators.and_then_no_lookahead",
"Prims.unit",
"LowParse.Spec.Combinators.and_then_injective",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.and_then_bare",
"FStar.Classical.forall_intro",
"Prims.l_iff",
"LowParse.Spec.Base.parser_kind_prop",
"LowParse.Spec.Base.parser_kind_prop'",
"LowParse.Spec.Combinators.and_then_cases_injective",
"Prims.squash",
"Prims.l_and",
"LowParse.Spec.Base.injective",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p') | false | false | LowParse.Spec.Combinators.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"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": 64,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val and_then_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(#k': parser_kind)
(#t': Type)
(p': (t -> Tot (parser k' t')))
: Lemma (requires (and_then_cases_injective p'))
(ensures
(injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p'))) | [] | LowParse.Spec.Combinators.and_then_correct | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: LowParse.Spec.Base.parser k t -> p': (_: t -> LowParse.Spec.Base.parser k' t')
-> FStar.Pervasives.Lemma (requires LowParse.Spec.Combinators.and_then_cases_injective p')
(ensures
LowParse.Spec.Base.injective (LowParse.Spec.Combinators.and_then_bare p p') /\
LowParse.Spec.Base.parser_kind_prop (LowParse.Spec.Combinators.and_then_kind k k')
(LowParse.Spec.Combinators.and_then_bare p p')) | {
"end_col": 28,
"end_line": 509,
"start_col": 2,
"start_line": 505
} |
Prims.GTot | val make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2 | val make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: GTot Type0
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: GTot Type0 = | false | null | false | forall (s1: bytes{Seq.length s1 == sz}) (s2: bytes{Seq.length s2 == sz}). {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2 | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"sometrivial"
] | [
"Prims.nat",
"LowParse.Bytes.bytes",
"Prims.eq2",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"FStar.Pervasives.Native.option",
"Prims.l_Forall",
"Prims.l_imp",
"LowParse.Spec.Combinators.make_constant_size_parser_precond_precond",
"Prims.l_or"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t))) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: GTot Type0 | [] | LowParse.Spec.Combinators.make_constant_size_parser_precond' | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
sz: Prims.nat ->
t: Type ->
f:
(s: LowParse.Bytes.bytes{FStar.Seq.Base.length s == sz}
-> Prims.GTot (FStar.Pervasives.Native.option t))
-> Prims.GTot Type0 | {
"end_col": 71,
"end_line": 54,
"start_col": 2,
"start_line": 53
} |
Prims.Tot | val constant_size_parser_kind (sz: nat) : Tot parser_kind | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None | val constant_size_parser_kind (sz: nat) : Tot parser_kind
let constant_size_parser_kind (sz: nat) : Tot parser_kind = | false | null | false | strong_parser_kind sz sz None | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"Prims.nat",
"LowParse.Spec.Base.strong_parser_kind",
"FStar.Pervasives.Native.None",
"LowParse.Spec.Base.parser_kind_metadata_some",
"LowParse.Spec.Base.parser_kind"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat) | false | true | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val constant_size_parser_kind (sz: nat) : Tot parser_kind | [] | LowParse.Spec.Combinators.constant_size_parser_kind | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | sz: Prims.nat -> LowParse.Spec.Base.parser_kind | {
"end_col": 31,
"end_line": 88,
"start_col": 2,
"start_line": 88
} |
FStar.Pervasives.Lemma | val and_then_no_lookahead_on
(#t #t': Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x x': bytes)
: Lemma (requires (no_lookahead p /\ injective p /\ (forall (x: t). no_lookahead (p' x))))
(ensures (no_lookahead_on (and_then_bare p p') x x')) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> () | val and_then_no_lookahead_on
(#t #t': Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x x': bytes)
: Lemma (requires (no_lookahead p /\ injective p /\ (forall (x: t). no_lookahead (p' x))))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on
(#t #t': Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x x': bytes)
: Lemma (requires (no_lookahead p /\ injective p /\ (forall (x: t). no_lookahead (p' x))))
(ensures (no_lookahead_on (and_then_bare p p') x x')) = | false | null | true | let f = and_then_bare p p' in
match f x with
| Some v ->
let y, off = v in
let off:nat = off in
let off_x:consumed_length x = off in
if off <= Seq.length x'
then
let off_x':consumed_length x' = off in
let g ()
: Lemma (requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures
(Some? (f x') /\
(let Some v' = f x' in
let y', off' = v' in
y == y'))) =
assert (Some? (p x));
let Some (y1, off1) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let Some v1' = p x' in
let y1', off1' = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2:bytes = Seq.slice x off1 (Seq.length x) in
let x2':bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let Some (y2, off2) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let Some v2' = p2 x2' in
let y2', _ = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
| _ -> () | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.bare_parser",
"LowParse.Bytes.bytes",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"FStar.Classical.move_requires",
"Prims.unit",
"Prims.eq2",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"Prims.l_and",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"Prims.logical",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Prims._assert",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.no_lookahead_on",
"Prims.op_Addition",
"Prims.int",
"Prims.nat",
"LowParse.Spec.Base.injective_precond",
"Prims.bool",
"LowParse.Spec.Combinators.and_then_bare",
"LowParse.Spec.Base.no_lookahead",
"LowParse.Spec.Base.injective",
"Prims.l_Forall"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
)) | false | false | LowParse.Spec.Combinators.fsti | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val and_then_no_lookahead_on
(#t #t': Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x x': bytes)
: Lemma (requires (no_lookahead p /\ injective p /\ (forall (x: t). no_lookahead (p' x))))
(ensures (no_lookahead_on (and_then_bare p p') x x')) | [] | LowParse.Spec.Combinators.and_then_no_lookahead_on | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.bare_parser t ->
p': (_: t -> LowParse.Spec.Base.bare_parser t') ->
x: LowParse.Bytes.bytes ->
x': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
LowParse.Spec.Base.no_lookahead p /\ LowParse.Spec.Base.injective p /\
(forall (x: t). LowParse.Spec.Base.no_lookahead (p' x)))
(ensures
LowParse.Spec.Base.no_lookahead_on (LowParse.Spec.Combinators.and_then_bare p p') x x') | {
"end_col": 13,
"end_line": 432,
"start_col": 1,
"start_line": 383
} |
Prims.Tot | val serialize_ret (#t: Type) (v: t) (v_unique: (v': t -> Lemma (v == v')))
: Tot (serializer (parse_ret v)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x) | val serialize_ret (#t: Type) (v: t) (v_unique: (v': t -> Lemma (v == v')))
: Tot (serializer (parse_ret v))
let serialize_ret (#t: Type) (v: t) (v_unique: (v': t -> Lemma (v == v')))
: Tot (serializer (parse_ret v)) = | false | null | false | mk_serializer (parse_ret v) (fun (x: t) -> Seq.empty) (fun x -> v_unique x) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern",
"LowParse.Spec.Base.mk_serializer",
"LowParse.Spec.Combinators.parse_ret_kind",
"LowParse.Spec.Combinators.parse_ret",
"FStar.Seq.Base.empty",
"LowParse.Bytes.byte",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.serializer"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v')) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val serialize_ret (#t: Type) (v: t) (v_unique: (v': t -> Lemma (v == v')))
: Tot (serializer (parse_ret v)) | [] | LowParse.Spec.Combinators.serialize_ret | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | v: t -> v_unique: (v': t -> FStar.Pervasives.Lemma (ensures v == v'))
-> LowParse.Spec.Base.serializer (LowParse.Spec.Combinators.parse_ret v) | {
"end_col": 25,
"end_line": 212,
"start_col": 2,
"start_line": 209
} |
Prims.GTot | val synth_inverse (#t1 #t2: Type) (f2: (t1 -> GTot t2)) (g1: (t2 -> GTot t1)) : GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x) | val synth_inverse (#t1 #t2: Type) (f2: (t1 -> GTot t2)) (g1: (t2 -> GTot t1)) : GTot Type0
let synth_inverse (#t1 #t2: Type) (f2: (t1 -> GTot t2)) (g1: (t2 -> GTot t1)) : GTot Type0 = | false | null | false | (forall (x: t2). {:pattern (f2 (g1 x))} f2 (g1 x) == x) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"sometrivial"
] | [
"Prims.l_Forall",
"Prims.eq2"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1)) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val synth_inverse (#t1 #t2: Type) (f2: (t1 -> GTot t2)) (g1: (t2 -> GTot t1)) : GTot Type0 | [] | LowParse.Spec.Combinators.synth_inverse | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | f2: (_: t1 -> Prims.GTot t2) -> g1: (_: t2 -> Prims.GTot t1) -> Prims.GTot Type0 | {
"end_col": 59,
"end_line": 699,
"start_col": 2,
"start_line": 699
} |
Prims.Tot | val parse_ret' (#t: Type) (v: t) : Tot (tot_bare_parser t) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b)) | val parse_ret' (#t: Type) (v: t) : Tot (tot_bare_parser t)
let parse_ret' (#t: Type) (v: t) : Tot (tot_bare_parser t) = | false | null | false | fun (b: bytes) -> Some (v, (0 <: consumed_length b)) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Bytes.bytes",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.tot_bare_parser"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val parse_ret' (#t: Type) (v: t) : Tot (tot_bare_parser t) | [] | LowParse.Spec.Combinators.parse_ret' | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | v: t -> LowParse.Spec.Base.tot_bare_parser t | {
"end_col": 54,
"end_line": 190,
"start_col": 2,
"start_line": 190
} |
Prims.GTot | val fail_parser_kind_precond (k: parser_kind) : GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high) | val fail_parser_kind_precond (k: parser_kind) : GTot Type0
let fail_parser_kind_precond (k: parser_kind) : GTot Type0 = | false | null | false | k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"sometrivial"
] | [
"LowParse.Spec.Base.parser_kind",
"Prims.l_and",
"Prims.b2t",
"Prims.op_disEquality",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_kind_metadata_some",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_metadata",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserKindMetadataTotal",
"Prims.l_imp",
"FStar.Pervasives.Native.uu___is_Some",
"Prims.nat",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"Prims.op_LessThanOrEqual",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Pervasives.Native.__proj__Some__item__v"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind) | false | false | LowParse.Spec.Combinators.fsti | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fail_parser_kind_precond (k: parser_kind) : GTot Type0 | [] | LowParse.Spec.Combinators.fail_parser_kind_precond | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | k: LowParse.Spec.Base.parser_kind -> Prims.GTot Type0 | {
"end_col": 80,
"end_line": 225,
"start_col": 2,
"start_line": 224
} |
Prims.Tot | val tot_parse_ret (#t: Type) (v: t) : Tot (tot_parser parse_ret_kind t) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v | val tot_parse_ret (#t: Type) (v: t) : Tot (tot_parser parse_ret_kind t)
let tot_parse_ret (#t: Type) (v: t) : Tot (tot_parser parse_ret_kind t) = | false | null | false | parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Combinators.parse_ret'",
"Prims.unit",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"LowParse.Spec.Combinators.parse_ret_kind",
"LowParse.Spec.Base.tot_parser"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val tot_parse_ret (#t: Type) (v: t) : Tot (tot_parser parse_ret_kind t) | [] | LowParse.Spec.Combinators.tot_parse_ret | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | v: t -> LowParse.Spec.Base.tot_parser LowParse.Spec.Combinators.parse_ret_kind t | {
"end_col": 14,
"end_line": 199,
"start_col": 2,
"start_line": 198
} |
Prims.Pure | val make_constant_size_parser
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: Pure (parser (constant_size_parser_kind sz) t)
(requires (make_constant_size_parser_precond sz t f))
(ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p | val make_constant_size_parser
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: Pure (parser (constant_size_parser_kind sz) t)
(requires (make_constant_size_parser_precond sz t f))
(ensures (fun _ -> True))
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: Pure (parser (constant_size_parser_kind sz) t)
(requires (make_constant_size_parser_precond sz t f))
(ensures (fun _ -> True)) = | false | null | false | let p:bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [] | [
"Prims.nat",
"LowParse.Bytes.bytes",
"Prims.eq2",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"FStar.Pervasives.Native.option",
"Prims.unit",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"LowParse.Spec.Combinators.constant_size_parser_kind",
"LowParse.Spec.Combinators.make_constant_size_parser_injective",
"LowParse.Spec.Base.bare_parser",
"LowParse.Spec.Combinators.make_constant_size_parser_aux",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Combinators.make_constant_size_parser_precond",
"Prims.l_True"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
)) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val make_constant_size_parser
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: Pure (parser (constant_size_parser_kind sz) t)
(requires (make_constant_size_parser_precond sz t f))
(ensures (fun _ -> True)) | [] | LowParse.Spec.Combinators.make_constant_size_parser | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
sz: Prims.nat ->
t: Type ->
f:
(s: LowParse.Bytes.bytes{FStar.Seq.Base.length s == sz}
-> Prims.GTot (FStar.Pervasives.Native.option t))
-> Prims.Pure
(LowParse.Spec.Base.parser (LowParse.Spec.Combinators.constant_size_parser_kind sz) t) | {
"end_col": 3,
"end_line": 106,
"start_col": 1,
"start_line": 103
} |
Prims.Tot | val synth_tagged_union_data
(#tag_t #data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x | val synth_tagged_union_data
(#tag_t #data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
let synth_tagged_union_data
(#tag_t #data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t = | false | null | false | x | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.refine_with_tag"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val synth_tagged_union_data
(#tag_t #data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t | [] | LowParse.Spec.Combinators.synth_tagged_union_data | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
tag_of_data: (_: data_t -> Prims.GTot tag_t) ->
tg: tag_t ->
x: LowParse.Spec.Base.refine_with_tag tag_of_data tg
-> data_t | {
"end_col": 3,
"end_line": 902,
"start_col": 2,
"start_line": 902
} |
Prims.Pure | val tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> Tot (option t)))
: Pure (tot_parser (constant_size_parser_kind sz) t)
(requires (make_constant_size_parser_precond sz t f))
(ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p | val tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> Tot (option t)))
: Pure (tot_parser (constant_size_parser_kind sz) t)
(requires (make_constant_size_parser_precond sz t f))
(ensures (fun _ -> True))
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> Tot (option t)))
: Pure (tot_parser (constant_size_parser_kind sz) t)
(requires (make_constant_size_parser_precond sz t f))
(ensures (fun _ -> True)) = | false | null | false | let p:tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [] | [
"Prims.nat",
"LowParse.Bytes.bytes",
"Prims.eq2",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"FStar.Pervasives.Native.option",
"Prims.unit",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"LowParse.Spec.Combinators.constant_size_parser_kind",
"LowParse.Spec.Combinators.make_constant_size_parser_injective",
"LowParse.Spec.Base.tot_bare_parser",
"LowParse.Spec.Combinators.tot_make_constant_size_parser_aux",
"LowParse.Spec.Base.tot_parser",
"LowParse.Spec.Combinators.make_constant_size_parser_precond",
"Prims.l_True"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
)) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> Tot (option t)))
: Pure (tot_parser (constant_size_parser_kind sz) t)
(requires (make_constant_size_parser_precond sz t f))
(ensures (fun _ -> True)) | [] | LowParse.Spec.Combinators.tot_make_constant_size_parser | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
sz: Prims.nat ->
t: Type ->
f: (s: LowParse.Bytes.bytes{FStar.Seq.Base.length s == sz} -> FStar.Pervasives.Native.option t)
-> Prims.Pure
(LowParse.Spec.Base.tot_parser (LowParse.Spec.Combinators.constant_size_parser_kind sz) t) | {
"end_col": 3,
"end_line": 141,
"start_col": 1,
"start_line": 138
} |
FStar.Pervasives.Lemma | val make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: Lemma (requires (make_constant_size_parser_precond sz t f))
(ensures (injective (make_constant_size_parser_aux sz t f))) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1)) | val make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: Lemma (requires (make_constant_size_parser_precond sz t f))
(ensures (injective (make_constant_size_parser_aux sz t f)))
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: Lemma (requires (make_constant_size_parser_precond sz t f))
(ensures (injective (make_constant_size_parser_aux sz t f))) = | false | null | true | let p:bare_parser t = make_constant_size_parser_aux sz t f in
let prf1 (b1 b2: bytes)
: Lemma (requires (injective_precond p b1 b2)) (ensures (injective_postcond p b1 b2)) =
assert (Some? (parse p b1));
assert (Some? (parse p b2));
let Some (v1, len1) = parse p b1 in
let Some (v2, len2) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz
t
f
(Seq.slice b1 0 len1)
(Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1)) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"Prims.nat",
"LowParse.Bytes.bytes",
"Prims.eq2",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"FStar.Pervasives.Native.option",
"FStar.Classical.forall_intro_2",
"Prims.l_imp",
"LowParse.Spec.Base.injective_precond",
"LowParse.Spec.Base.injective_postcond",
"FStar.Classical.move_requires",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"LowParse.Spec.Base.consumed_length",
"Prims._assert",
"LowParse.Spec.Combinators.make_constant_size_parser_precond'",
"LowParse.Spec.Combinators.make_constant_size_parser_precond_precond",
"FStar.Seq.Base.slice",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.parse",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"LowParse.Spec.Base.bare_parser",
"LowParse.Spec.Combinators.make_constant_size_parser_aux",
"LowParse.Spec.Combinators.make_constant_size_parser_precond",
"LowParse.Spec.Base.injective"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: Lemma (requires (make_constant_size_parser_precond sz t f))
(ensures (injective (make_constant_size_parser_aux sz t f))) | [] | LowParse.Spec.Combinators.make_constant_size_parser_injective | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
sz: Prims.nat ->
t: Type ->
f:
(s: LowParse.Bytes.bytes{FStar.Seq.Base.length s == sz}
-> Prims.GTot (FStar.Pervasives.Native.option t))
-> FStar.Pervasives.Lemma
(requires LowParse.Spec.Combinators.make_constant_size_parser_precond sz t f)
(ensures
LowParse.Spec.Base.injective (LowParse.Spec.Combinators.make_constant_size_parser_aux sz t f
)) | {
"end_col": 81,
"end_line": 83,
"start_col": 1,
"start_line": 67
} |
Prims.Tot | val bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2) | val bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2)) = | false | null | false | fun (x: t1 * t2) ->
let x1, x2 = x in
Seq.append (s1 x1) (s2 x2) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"FStar.Pervasives.Native.tuple2",
"FStar.Seq.Base.append",
"LowParse.Bytes.byte",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.bare_serializer"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2) | false | false | LowParse.Spec.Combinators.fsti | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2)) | [] | LowParse.Spec.Combinators.bare_serialize_nondep_then | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p1: LowParse.Spec.Base.parser k1 t1 ->
s1: LowParse.Spec.Base.serializer p1 ->
p2: LowParse.Spec.Base.parser k2 t2 ->
s2: LowParse.Spec.Base.serializer p2
-> LowParse.Spec.Base.bare_serializer (t1 * t2) | {
"end_col": 28,
"end_line": 1369,
"start_col": 2,
"start_line": 1367
} |
Prims.Tot | val bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(s: (t: tag_t -> Tot (serializer (p t))))
: Tot (bare_serializer data_t) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d) | val bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(s: (t: tag_t -> Tot (serializer (p t))))
: Tot (bare_serializer data_t)
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(s: (t: tag_t -> Tot (serializer (p t))))
: Tot (bare_serializer data_t) = | false | null | false | fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.Base.refine_with_tag",
"FStar.Seq.Base.append",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.serialize",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.bare_serializer"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t))) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(s: (t: tag_t -> Tot (serializer (p t))))
: Tot (bare_serializer data_t) | [] | LowParse.Spec.Combinators.bare_serialize_tagged_union | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
st: LowParse.Spec.Base.serializer pt ->
tag_of_data: (_: data_t -> Prims.GTot tag_t) ->
s: (t: tag_t -> LowParse.Spec.Base.serializer (p t))
-> LowParse.Spec.Base.bare_serializer data_t | {
"end_col": 41,
"end_line": 1065,
"start_col": 2,
"start_line": 1063
} |
Prims.GTot | val compose (#t1 #t2 #t3: Type) (f1: (t1 -> GTot t2)) (f2: (t2 -> GTot t3)) (x: t1) : GTot t3 | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let compose (#t1 #t2 #t3: Type) (f1: t1 -> GTot t2) (f2: t2 -> GTot t3) (x: t1) : GTot t3 =
let y1 = f1 x in
f2 y1 | val compose (#t1 #t2 #t3: Type) (f1: (t1 -> GTot t2)) (f2: (t2 -> GTot t3)) (x: t1) : GTot t3
let compose (#t1 #t2 #t3: Type) (f1: (t1 -> GTot t2)) (f2: (t2 -> GTot t3)) (x: t1) : GTot t3 = | false | null | false | let y1 = f1 x in
f2 y1 | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"sometrivial"
] | [] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2)
val serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
: Tot (serializer (nondep_then p1 p2))
val serialize_nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input: t1 * t2)
: Lemma
(serialize (serialize_nondep_then s1 s2) input == bare_serialize_nondep_then p1 s1 p2 s2 input)
val length_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input1: t1)
(input2: t2)
: Lemma
(Seq.length (serialize (serialize_nondep_then s1 s2) (input1, input2)) == Seq.length (serialize s1 input1) + Seq.length (serialize s2 input2))
val serialize_nondep_then_upd_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s 0 (serialize s1 y)
))
val serialize_nondep_then_upd_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s i' s'
))
val serialize_nondep_then_upd_bw_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s len2 (serialize s1 y)
))
#reset-options "--z3refresh --z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val serialize_nondep_then_upd_bw_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_bw_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s (len2 + i') s'
))
val serialize_nondep_then_upd_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (Seq.length s - Seq.length (serialize s2 y)) (serialize s2 y)
))
val serialize_nondep_then_upd_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
l1 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (l1 + i') s'
))
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y)
))
= serialize_nondep_then_upd_right s1 s2 x y
let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_bw_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s'
))
= let s2' = serialize s2 (snd x) in
let j' = Seq.length s2' - i' - Seq.length s' in
assert (j' + Seq.length s' <= Seq.length s2');
assert (serialize s2 y == seq_upd_seq s2' j' s');
let s = serialize (serialize_nondep_then s1 s2) x in
serialize_nondep_then_upd_right_chain s1 s2 x y j' s';
assert (Seq.length (serialize s1 (fst x)) + j' == Seq.length s - i' - Seq.length s');
()
#reset-options "--z3rlimit 32 --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Apply a total transformation on parsed data *)
let parse_strengthen_prf
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
: Tot Type
= (xbytes: bytes) ->
(consumed: consumed_length xbytes) ->
(x: t1) ->
Lemma
(requires (parse p1 xbytes == Some (x, consumed)))
(ensures (p2 x))
let bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1 { p2 x } ))
= fun (xbytes: bytes) ->
match parse p1 xbytes with
| Some (x, consumed) ->
prf xbytes consumed x;
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
let bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf))
= let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . no_lookahead_on p1 b1 b2 ==> no_lookahead_on p' b1 b2)
let bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . injective_precond p' b1 b2 ==> injective_precond p1 b1 b2);
assert (forall (b1 b2: bytes) . injective_postcond p1 b1 b2 ==> injective_postcond p' b1 b2)
let bare_parse_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf) /\
parser_kind_prop k (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
bare_parse_strengthen_no_lookahead p1 p2 prf;
bare_parse_strengthen_injective p1 p2 prf;
parser_kind_prop_equiv k (bare_parse_strengthen p1 p2 prf);
()
let parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser k (x: t1 { p2 x } ))
= bare_parse_strengthen_correct p1 p2 prf;
bare_parse_strengthen p1 p2 prf
let serialize_strengthen'
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: GTot bytes
= serialize s input
let serialize_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: Lemma
(let output = serialize_strengthen' p2 prf s input in
parse (parse_strengthen p1 p2 prf) output == Some (input, Seq.length output))
= ()
let serialize_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
: Tot (serializer (parse_strengthen p1 p2 prf))
= Classical.forall_intro (serialize_strengthen_correct p2 prf s);
serialize_strengthen' p2 prf s | false | false | LowParse.Spec.Combinators.fsti | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val compose (#t1 #t2 #t3: Type) (f1: (t1 -> GTot t2)) (f2: (t2 -> GTot t3)) (x: t1) : GTot t3 | [] | LowParse.Spec.Combinators.compose | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | f1: (_: t1 -> Prims.GTot t2) -> f2: (_: t2 -> Prims.GTot t3) -> x: t1 -> Prims.GTot t3 | {
"end_col": 7,
"end_line": 1720,
"start_col": 91,
"start_line": 1718
} |
Prims.Tot | val parse_filter_payload_kind:parser_kind | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let parse_filter_payload_kind : parser_kind =
strong_parser_kind 0 0 None | val parse_filter_payload_kind:parser_kind
let parse_filter_payload_kind:parser_kind = | false | null | false | strong_parser_kind 0 0 None | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.strong_parser_kind",
"FStar.Pervasives.Native.None",
"LowParse.Spec.Base.parser_kind_metadata_some"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2)
val serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
: Tot (serializer (nondep_then p1 p2))
val serialize_nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input: t1 * t2)
: Lemma
(serialize (serialize_nondep_then s1 s2) input == bare_serialize_nondep_then p1 s1 p2 s2 input)
val length_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input1: t1)
(input2: t2)
: Lemma
(Seq.length (serialize (serialize_nondep_then s1 s2) (input1, input2)) == Seq.length (serialize s1 input1) + Seq.length (serialize s2 input2))
val serialize_nondep_then_upd_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s 0 (serialize s1 y)
))
val serialize_nondep_then_upd_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s i' s'
))
val serialize_nondep_then_upd_bw_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s len2 (serialize s1 y)
))
#reset-options "--z3refresh --z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val serialize_nondep_then_upd_bw_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_bw_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s (len2 + i') s'
))
val serialize_nondep_then_upd_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (Seq.length s - Seq.length (serialize s2 y)) (serialize s2 y)
))
val serialize_nondep_then_upd_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
l1 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (l1 + i') s'
))
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y)
))
= serialize_nondep_then_upd_right s1 s2 x y
let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_bw_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s'
))
= let s2' = serialize s2 (snd x) in
let j' = Seq.length s2' - i' - Seq.length s' in
assert (j' + Seq.length s' <= Seq.length s2');
assert (serialize s2 y == seq_upd_seq s2' j' s');
let s = serialize (serialize_nondep_then s1 s2) x in
serialize_nondep_then_upd_right_chain s1 s2 x y j' s';
assert (Seq.length (serialize s1 (fst x)) + j' == Seq.length s - i' - Seq.length s');
()
#reset-options "--z3rlimit 32 --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Apply a total transformation on parsed data *)
let parse_strengthen_prf
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
: Tot Type
= (xbytes: bytes) ->
(consumed: consumed_length xbytes) ->
(x: t1) ->
Lemma
(requires (parse p1 xbytes == Some (x, consumed)))
(ensures (p2 x))
let bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1 { p2 x } ))
= fun (xbytes: bytes) ->
match parse p1 xbytes with
| Some (x, consumed) ->
prf xbytes consumed x;
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
let bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf))
= let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . no_lookahead_on p1 b1 b2 ==> no_lookahead_on p' b1 b2)
let bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . injective_precond p' b1 b2 ==> injective_precond p1 b1 b2);
assert (forall (b1 b2: bytes) . injective_postcond p1 b1 b2 ==> injective_postcond p' b1 b2)
let bare_parse_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf) /\
parser_kind_prop k (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
bare_parse_strengthen_no_lookahead p1 p2 prf;
bare_parse_strengthen_injective p1 p2 prf;
parser_kind_prop_equiv k (bare_parse_strengthen p1 p2 prf);
()
let parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser k (x: t1 { p2 x } ))
= bare_parse_strengthen_correct p1 p2 prf;
bare_parse_strengthen p1 p2 prf
let serialize_strengthen'
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: GTot bytes
= serialize s input
let serialize_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: Lemma
(let output = serialize_strengthen' p2 prf s input in
parse (parse_strengthen p1 p2 prf) output == Some (input, Seq.length output))
= ()
let serialize_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
: Tot (serializer (parse_strengthen p1 p2 prf))
= Classical.forall_intro (serialize_strengthen_correct p2 prf s);
serialize_strengthen' p2 prf s
let compose (#t1 #t2 #t3: Type) (f1: t1 -> GTot t2) (f2: t2 -> GTot t3) (x: t1) : GTot t3 =
let y1 = f1 x in
f2 y1
val make_total_constant_size_parser_compose
(sz: nat)
(t1 t2: Type)
(f1: ((s: bytes {Seq.length s == sz}) -> GTot t1))
(g2: t1 -> GTot t2)
: Lemma
(requires (
make_total_constant_size_parser_precond sz t1 f1 /\
(forall x x' . g2 x == g2 x' ==> x == x')
))
(ensures (
make_total_constant_size_parser_precond sz t1 f1 /\
make_total_constant_size_parser_precond sz t2 (f1 `compose` g2) /\
(forall x x' . {:pattern (g2 x); (g2 x')} g2 x == g2 x' ==> x == x') /\
(forall input . {:pattern (parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input)} parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input == parse (make_total_constant_size_parser sz t1 f1 `parse_synth` g2) input)
))
(** Tot vs. Ghost *)
unfold
let lift_parser'
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (bare_parser t)
= fun (input: bytes) -> parse (f ()) input
let lift_parser_correct
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Lemma
(parser_kind_prop k (lift_parser' f))
= parser_kind_prop_ext k (f ()) (lift_parser' f)
let lift_parser
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (parser k t)
= lift_parser_correct f;
lift_parser' f
unfold
let lift_serializer'
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Tot (bare_serializer t)
= fun (x: t) -> serialize (s ()) x
let lift_serializer_correct
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Lemma
(serializer_correct (lift_parser f) (lift_serializer' s))
= ()
let lift_serializer
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Tot (serializer #k #t (lift_parser f))
= lift_serializer_correct #k #t #f s;
lift_serializer' #k #t #f s
(** Refinements *)
// unfold
inline_for_extraction
let parse_filter_kind (k: parser_kind) : Tot parser_kind =
{
parser_kind_low = k.parser_kind_low;
parser_kind_high = k.parser_kind_high;
parser_kind_metadata =
begin match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
end;
parser_kind_subkind = k.parser_kind_subkind;
}
// unfold | false | true | LowParse.Spec.Combinators.fsti | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_filter_payload_kind:parser_kind | [] | LowParse.Spec.Combinators.parse_filter_payload_kind | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | LowParse.Spec.Base.parser_kind | {
"end_col": 29,
"end_line": 1810,
"start_col": 2,
"start_line": 1810
} |
Prims.Pure | val tot_fail_parser (k: parser_kind) (t: Type)
: Pure (tot_parser k t) (requires (fail_parser_kind_precond k)) (ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p | val tot_fail_parser (k: parser_kind) (t: Type)
: Pure (tot_parser k t) (requires (fail_parser_kind_precond k)) (ensures (fun _ -> True))
let tot_fail_parser (k: parser_kind) (t: Type)
: Pure (tot_parser k t) (requires (fail_parser_kind_precond k)) (ensures (fun _ -> True)) = | false | null | false | let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.tot_strengthen",
"Prims.unit",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"LowParse.Spec.Base.tot_bare_parser",
"LowParse.Spec.Combinators.fail_parser'",
"LowParse.Spec.Base.tot_parser",
"LowParse.Spec.Combinators.fail_parser_kind_precond",
"Prims.l_True"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k)) | false | false | LowParse.Spec.Combinators.fsti | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tot_fail_parser (k: parser_kind) (t: Type)
: Pure (tot_parser k t) (requires (fail_parser_kind_precond k)) (ensures (fun _ -> True)) | [] | LowParse.Spec.Combinators.tot_fail_parser | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | k: LowParse.Spec.Base.parser_kind -> t: Type -> Prims.Pure (LowParse.Spec.Base.tot_parser k t) | {
"end_col": 20,
"end_line": 240,
"start_col": 1,
"start_line": 238
} |
Prims.Tot | val serialize_filter'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(f: (t -> GTot bool))
: Tot (bare_serializer (x: t{f x == true})) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let serialize_filter'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(f: (t -> GTot bool))
: Tot (bare_serializer (x: t { f x == true } ))
= fun (input: t { f input == true } ) -> s input | val serialize_filter'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(f: (t -> GTot bool))
: Tot (bare_serializer (x: t{f x == true}))
let serialize_filter'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(f: (t -> GTot bool))
: Tot (bare_serializer (x: t{f x == true})) = | false | null | false | fun (input: t{f input == true}) -> s input | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.bool",
"Prims.eq2",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.bare_serializer"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2)
val serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
: Tot (serializer (nondep_then p1 p2))
val serialize_nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input: t1 * t2)
: Lemma
(serialize (serialize_nondep_then s1 s2) input == bare_serialize_nondep_then p1 s1 p2 s2 input)
val length_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input1: t1)
(input2: t2)
: Lemma
(Seq.length (serialize (serialize_nondep_then s1 s2) (input1, input2)) == Seq.length (serialize s1 input1) + Seq.length (serialize s2 input2))
val serialize_nondep_then_upd_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s 0 (serialize s1 y)
))
val serialize_nondep_then_upd_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s i' s'
))
val serialize_nondep_then_upd_bw_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s len2 (serialize s1 y)
))
#reset-options "--z3refresh --z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val serialize_nondep_then_upd_bw_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_bw_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s (len2 + i') s'
))
val serialize_nondep_then_upd_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (Seq.length s - Seq.length (serialize s2 y)) (serialize s2 y)
))
val serialize_nondep_then_upd_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
l1 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (l1 + i') s'
))
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y)
))
= serialize_nondep_then_upd_right s1 s2 x y
let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_bw_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s'
))
= let s2' = serialize s2 (snd x) in
let j' = Seq.length s2' - i' - Seq.length s' in
assert (j' + Seq.length s' <= Seq.length s2');
assert (serialize s2 y == seq_upd_seq s2' j' s');
let s = serialize (serialize_nondep_then s1 s2) x in
serialize_nondep_then_upd_right_chain s1 s2 x y j' s';
assert (Seq.length (serialize s1 (fst x)) + j' == Seq.length s - i' - Seq.length s');
()
#reset-options "--z3rlimit 32 --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Apply a total transformation on parsed data *)
let parse_strengthen_prf
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
: Tot Type
= (xbytes: bytes) ->
(consumed: consumed_length xbytes) ->
(x: t1) ->
Lemma
(requires (parse p1 xbytes == Some (x, consumed)))
(ensures (p2 x))
let bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1 { p2 x } ))
= fun (xbytes: bytes) ->
match parse p1 xbytes with
| Some (x, consumed) ->
prf xbytes consumed x;
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
let bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf))
= let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . no_lookahead_on p1 b1 b2 ==> no_lookahead_on p' b1 b2)
let bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . injective_precond p' b1 b2 ==> injective_precond p1 b1 b2);
assert (forall (b1 b2: bytes) . injective_postcond p1 b1 b2 ==> injective_postcond p' b1 b2)
let bare_parse_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf) /\
parser_kind_prop k (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
bare_parse_strengthen_no_lookahead p1 p2 prf;
bare_parse_strengthen_injective p1 p2 prf;
parser_kind_prop_equiv k (bare_parse_strengthen p1 p2 prf);
()
let parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser k (x: t1 { p2 x } ))
= bare_parse_strengthen_correct p1 p2 prf;
bare_parse_strengthen p1 p2 prf
let serialize_strengthen'
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: GTot bytes
= serialize s input
let serialize_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: Lemma
(let output = serialize_strengthen' p2 prf s input in
parse (parse_strengthen p1 p2 prf) output == Some (input, Seq.length output))
= ()
let serialize_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
: Tot (serializer (parse_strengthen p1 p2 prf))
= Classical.forall_intro (serialize_strengthen_correct p2 prf s);
serialize_strengthen' p2 prf s
let compose (#t1 #t2 #t3: Type) (f1: t1 -> GTot t2) (f2: t2 -> GTot t3) (x: t1) : GTot t3 =
let y1 = f1 x in
f2 y1
val make_total_constant_size_parser_compose
(sz: nat)
(t1 t2: Type)
(f1: ((s: bytes {Seq.length s == sz}) -> GTot t1))
(g2: t1 -> GTot t2)
: Lemma
(requires (
make_total_constant_size_parser_precond sz t1 f1 /\
(forall x x' . g2 x == g2 x' ==> x == x')
))
(ensures (
make_total_constant_size_parser_precond sz t1 f1 /\
make_total_constant_size_parser_precond sz t2 (f1 `compose` g2) /\
(forall x x' . {:pattern (g2 x); (g2 x')} g2 x == g2 x' ==> x == x') /\
(forall input . {:pattern (parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input)} parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input == parse (make_total_constant_size_parser sz t1 f1 `parse_synth` g2) input)
))
(** Tot vs. Ghost *)
unfold
let lift_parser'
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (bare_parser t)
= fun (input: bytes) -> parse (f ()) input
let lift_parser_correct
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Lemma
(parser_kind_prop k (lift_parser' f))
= parser_kind_prop_ext k (f ()) (lift_parser' f)
let lift_parser
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (parser k t)
= lift_parser_correct f;
lift_parser' f
unfold
let lift_serializer'
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Tot (bare_serializer t)
= fun (x: t) -> serialize (s ()) x
let lift_serializer_correct
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Lemma
(serializer_correct (lift_parser f) (lift_serializer' s))
= ()
let lift_serializer
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Tot (serializer #k #t (lift_parser f))
= lift_serializer_correct #k #t #f s;
lift_serializer' #k #t #f s
(** Refinements *)
// unfold
inline_for_extraction
let parse_filter_kind (k: parser_kind) : Tot parser_kind =
{
parser_kind_low = k.parser_kind_low;
parser_kind_high = k.parser_kind_high;
parser_kind_metadata =
begin match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
end;
parser_kind_subkind = k.parser_kind_subkind;
}
// unfold
let parse_filter_payload_kind : parser_kind =
strong_parser_kind 0 0 None
let parse_filter_refine (#t: Type) (f: (t -> GTot bool)) =
(x: t { f x == true } )
let parse_filter_payload
(#t: Type)
(f: (t -> GTot bool))
(v: t)
: Tot (parser parse_filter_payload_kind (parse_filter_refine f))
= let p = lift_parser (fun () ->
if f v
then
let v' : (x: t { f x == true } ) = v in
weaken parse_filter_payload_kind (parse_ret v')
else fail_parser parse_filter_payload_kind (parse_filter_refine f)
)
in
parser_kind_prop_equiv parse_filter_payload_kind p;
p
val parse_filter
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
: Tot (parser (parse_filter_kind k) (parse_filter_refine f))
val parse_filter_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: bytes)
: Lemma
(parse (parse_filter p f) input == (match parse p input with
| None -> None
| Some (x, consumed) ->
if f x
then Some (x, consumed)
else None
))
val tot_parse_filter
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(f: (t -> Tot bool))
: Pure (tot_parser (parse_filter_kind k) (parse_filter_refine f))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_filter #k p f) x
))
let tot_parse_filter_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(f: (t -> Tot bool))
(input: bytes)
: Lemma
(parse (tot_parse_filter p f) input == (match parse p input with
| None -> None
| Some (x, consumed) ->
if f x
then Some (x, consumed)
else None
))
= parse_filter_eq #k p f input
let serialize_filter'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(f: (t -> GTot bool)) | false | false | LowParse.Spec.Combinators.fsti | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_filter'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(f: (t -> GTot bool))
: Tot (bare_serializer (x: t{f x == true})) | [] | LowParse.Spec.Combinators.serialize_filter' | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | s: LowParse.Spec.Base.serializer p -> f: (_: t -> Prims.GTot Prims.bool)
-> LowParse.Spec.Base.bare_serializer (x: t{f x == true}) | {
"end_col": 48,
"end_line": 1887,
"start_col": 2,
"start_line": 1887
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let parse_filter_refine (#t: Type) (f: (t -> GTot bool)) =
(x: t { f x == true } ) | let parse_filter_refine (#t: Type) (f: (t -> GTot bool)) = | false | null | false | (x: t{f x == true}) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"Prims.bool",
"Prims.eq2"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2)
val serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
: Tot (serializer (nondep_then p1 p2))
val serialize_nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input: t1 * t2)
: Lemma
(serialize (serialize_nondep_then s1 s2) input == bare_serialize_nondep_then p1 s1 p2 s2 input)
val length_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input1: t1)
(input2: t2)
: Lemma
(Seq.length (serialize (serialize_nondep_then s1 s2) (input1, input2)) == Seq.length (serialize s1 input1) + Seq.length (serialize s2 input2))
val serialize_nondep_then_upd_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s 0 (serialize s1 y)
))
val serialize_nondep_then_upd_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s i' s'
))
val serialize_nondep_then_upd_bw_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s len2 (serialize s1 y)
))
#reset-options "--z3refresh --z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val serialize_nondep_then_upd_bw_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_bw_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s (len2 + i') s'
))
val serialize_nondep_then_upd_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (Seq.length s - Seq.length (serialize s2 y)) (serialize s2 y)
))
val serialize_nondep_then_upd_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
l1 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (l1 + i') s'
))
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y)
))
= serialize_nondep_then_upd_right s1 s2 x y
let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_bw_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s'
))
= let s2' = serialize s2 (snd x) in
let j' = Seq.length s2' - i' - Seq.length s' in
assert (j' + Seq.length s' <= Seq.length s2');
assert (serialize s2 y == seq_upd_seq s2' j' s');
let s = serialize (serialize_nondep_then s1 s2) x in
serialize_nondep_then_upd_right_chain s1 s2 x y j' s';
assert (Seq.length (serialize s1 (fst x)) + j' == Seq.length s - i' - Seq.length s');
()
#reset-options "--z3rlimit 32 --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Apply a total transformation on parsed data *)
let parse_strengthen_prf
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
: Tot Type
= (xbytes: bytes) ->
(consumed: consumed_length xbytes) ->
(x: t1) ->
Lemma
(requires (parse p1 xbytes == Some (x, consumed)))
(ensures (p2 x))
let bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1 { p2 x } ))
= fun (xbytes: bytes) ->
match parse p1 xbytes with
| Some (x, consumed) ->
prf xbytes consumed x;
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
let bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf))
= let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . no_lookahead_on p1 b1 b2 ==> no_lookahead_on p' b1 b2)
let bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . injective_precond p' b1 b2 ==> injective_precond p1 b1 b2);
assert (forall (b1 b2: bytes) . injective_postcond p1 b1 b2 ==> injective_postcond p' b1 b2)
let bare_parse_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf) /\
parser_kind_prop k (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
bare_parse_strengthen_no_lookahead p1 p2 prf;
bare_parse_strengthen_injective p1 p2 prf;
parser_kind_prop_equiv k (bare_parse_strengthen p1 p2 prf);
()
let parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser k (x: t1 { p2 x } ))
= bare_parse_strengthen_correct p1 p2 prf;
bare_parse_strengthen p1 p2 prf
let serialize_strengthen'
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: GTot bytes
= serialize s input
let serialize_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: Lemma
(let output = serialize_strengthen' p2 prf s input in
parse (parse_strengthen p1 p2 prf) output == Some (input, Seq.length output))
= ()
let serialize_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
: Tot (serializer (parse_strengthen p1 p2 prf))
= Classical.forall_intro (serialize_strengthen_correct p2 prf s);
serialize_strengthen' p2 prf s
let compose (#t1 #t2 #t3: Type) (f1: t1 -> GTot t2) (f2: t2 -> GTot t3) (x: t1) : GTot t3 =
let y1 = f1 x in
f2 y1
val make_total_constant_size_parser_compose
(sz: nat)
(t1 t2: Type)
(f1: ((s: bytes {Seq.length s == sz}) -> GTot t1))
(g2: t1 -> GTot t2)
: Lemma
(requires (
make_total_constant_size_parser_precond sz t1 f1 /\
(forall x x' . g2 x == g2 x' ==> x == x')
))
(ensures (
make_total_constant_size_parser_precond sz t1 f1 /\
make_total_constant_size_parser_precond sz t2 (f1 `compose` g2) /\
(forall x x' . {:pattern (g2 x); (g2 x')} g2 x == g2 x' ==> x == x') /\
(forall input . {:pattern (parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input)} parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input == parse (make_total_constant_size_parser sz t1 f1 `parse_synth` g2) input)
))
(** Tot vs. Ghost *)
unfold
let lift_parser'
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (bare_parser t)
= fun (input: bytes) -> parse (f ()) input
let lift_parser_correct
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Lemma
(parser_kind_prop k (lift_parser' f))
= parser_kind_prop_ext k (f ()) (lift_parser' f)
let lift_parser
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (parser k t)
= lift_parser_correct f;
lift_parser' f
unfold
let lift_serializer'
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Tot (bare_serializer t)
= fun (x: t) -> serialize (s ()) x
let lift_serializer_correct
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Lemma
(serializer_correct (lift_parser f) (lift_serializer' s))
= ()
let lift_serializer
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Tot (serializer #k #t (lift_parser f))
= lift_serializer_correct #k #t #f s;
lift_serializer' #k #t #f s
(** Refinements *)
// unfold
inline_for_extraction
let parse_filter_kind (k: parser_kind) : Tot parser_kind =
{
parser_kind_low = k.parser_kind_low;
parser_kind_high = k.parser_kind_high;
parser_kind_metadata =
begin match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
end;
parser_kind_subkind = k.parser_kind_subkind;
}
// unfold
let parse_filter_payload_kind : parser_kind =
strong_parser_kind 0 0 None | false | false | LowParse.Spec.Combinators.fsti | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_filter_refine : f: (_: t -> Prims.GTot Prims.bool) -> Type | [] | LowParse.Spec.Combinators.parse_filter_refine | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | f: (_: t -> Prims.GTot Prims.bool) -> Type | {
"end_col": 25,
"end_line": 1813,
"start_col": 2,
"start_line": 1813
} |
|
Prims.Pure | val fail_parser (k: parser_kind) (t: Type)
: Pure (parser k t) (requires (fail_parser_kind_precond k)) (ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t | val fail_parser (k: parser_kind) (t: Type)
: Pure (parser k t) (requires (fail_parser_kind_precond k)) (ensures (fun _ -> True))
let fail_parser (k: parser_kind) (t: Type)
: Pure (parser k t) (requires (fail_parser_kind_precond k)) (ensures (fun _ -> True)) = | false | null | false | tot_fail_parser k t | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Combinators.tot_fail_parser",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Combinators.fail_parser_kind_precond",
"Prims.l_True"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k)) | false | false | LowParse.Spec.Combinators.fsti | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fail_parser (k: parser_kind) (t: Type)
: Pure (parser k t) (requires (fail_parser_kind_precond k)) (ensures (fun _ -> True)) | [] | LowParse.Spec.Combinators.fail_parser | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | k: LowParse.Spec.Base.parser_kind -> t: Type -> Prims.Pure (LowParse.Spec.Base.parser k t) | {
"end_col": 21,
"end_line": 248,
"start_col": 2,
"start_line": 248
} |
Prims.Tot | val parse_false:parser parse_false_kind (squash False) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let parse_false : parser parse_false_kind (squash False) = fail_parser _ _ | val parse_false:parser parse_false_kind (squash False)
let parse_false:parser parse_false_kind (squash False) = | false | null | false | fail_parser _ _ | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Combinators.fail_parser",
"LowParse.Spec.Combinators.parse_false_kind",
"Prims.squash",
"Prims.l_False"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail) | false | true | LowParse.Spec.Combinators.fsti | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_false:parser parse_false_kind (squash False) | [] | LowParse.Spec.Combinators.parse_false | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | LowParse.Spec.Base.parser LowParse.Spec.Combinators.parse_false_kind (Prims.squash Prims.l_False) | {
"end_col": 74,
"end_line": 263,
"start_col": 59,
"start_line": 263
} |
Prims.Tot | val and_then_bare (#t #t': Type) (p: bare_parser t) (p': (t -> Tot (bare_parser t')))
: Tot (bare_parser t') | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None | val and_then_bare (#t #t': Type) (p: bare_parser t) (p': (t -> Tot (bare_parser t')))
: Tot (bare_parser t')
let and_then_bare (#t #t': Type) (p: bare_parser t) (p': (t -> Tot (bare_parser t')))
: Tot (bare_parser t') = | false | null | false | fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
let p'v = p' v in
let s':bytes = Seq.slice b l (Seq.length b) in
(match parse p'v s' with
| Some (v', l') ->
let res:consumed_length b = l + l' in
Some (v', res)
| None -> None)
| None -> None | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.bare_parser",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Base.consumed_length",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"Prims.op_Addition",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"FStar.Seq.Base.slice",
"LowParse.Bytes.byte",
"FStar.Seq.Base.length"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) : | false | false | LowParse.Spec.Combinators.fsti | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val and_then_bare (#t #t': Type) (p: bare_parser t) (p': (t -> Tot (bare_parser t')))
: Tot (bare_parser t') | [] | LowParse.Spec.Combinators.and_then_bare | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: LowParse.Spec.Base.bare_parser t -> p': (_: t -> LowParse.Spec.Base.bare_parser t')
-> LowParse.Spec.Base.bare_parser t' | {
"end_col": 18,
"end_line": 285,
"start_col": 4,
"start_line": 273
} |
Prims.Tot | val serialize_false:serializer parse_false | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let serialize_false : serializer parse_false = fun input -> false_elim () | val serialize_false:serializer parse_false
let serialize_false:serializer parse_false = | false | null | false | fun input -> false_elim () | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"Prims.squash",
"Prims.l_False",
"FStar.Pervasives.false_elim",
"LowParse.Bytes.bytes"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _ | false | true | LowParse.Spec.Combinators.fsti | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_false:serializer parse_false | [] | LowParse.Spec.Combinators.serialize_false | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | LowParse.Spec.Base.serializer LowParse.Spec.Combinators.parse_false | {
"end_col": 73,
"end_line": 265,
"start_col": 47,
"start_line": 265
} |
Prims.GTot | val and_then_cases_injective_precond
(#t #t': Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
) | val and_then_cases_injective_precond
(#t #t': Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
let and_then_cases_injective_precond
(#t #t': Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0 = | false | null | false | Some? (parse (p' x1) b1) /\ Some? (parse (p' x2) b2) /\
(let Some (v1, _) = parse (p' x1) b1 in
let Some (v2, _) = parse (p' x2) b2 in
v1 == v2) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"sometrivial"
] | [
"LowParse.Spec.Base.bare_parser",
"LowParse.Bytes.bytes",
"Prims.l_and",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Base.parse",
"Prims.eq2",
"Prims.logical",
"FStar.Pervasives.Native.option"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes) | false | false | LowParse.Spec.Combinators.fsti | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val and_then_cases_injective_precond
(#t #t': Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0 | [] | LowParse.Spec.Combinators.and_then_cases_injective_precond | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p': (_: t -> LowParse.Spec.Base.bare_parser t') ->
x1: t ->
x2: t ->
b1: LowParse.Bytes.bytes ->
b2: LowParse.Bytes.bytes
-> Prims.GTot Type0 | {
"end_col": 3,
"end_line": 299,
"start_col": 2,
"start_line": 294
} |
FStar.Pervasives.Lemma | val synth_inverse_synth_injective_pat (#t1 #t2: Type) (f: (t1 -> GTot t2)) (g: (t2 -> GTot t1))
: Lemma (requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)] | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2)) | val synth_inverse_synth_injective_pat (#t1 #t2: Type) (f: (t1 -> GTot t2)) (g: (t2 -> GTot t1))
: Lemma (requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
let synth_inverse_synth_injective_pat (#t1 #t2: Type) (f: (t1 -> GTot t2)) (g: (t2 -> GTot t1))
: Lemma (requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)] = | false | null | true | assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2)) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"Prims._assert",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.eq2",
"Prims.unit",
"LowParse.Spec.Combinators.synth_inverse",
"Prims.squash",
"LowParse.Spec.Combinators.synth_injective",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f)) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val synth_inverse_synth_injective_pat (#t1 #t2: Type) (f: (t1 -> GTot t2)) (g: (t2 -> GTot t1))
: Lemma (requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)] | [] | LowParse.Spec.Combinators.synth_inverse_synth_injective_pat | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | f: (_: t1 -> Prims.GTot t2) -> g: (_: t2 -> Prims.GTot t1)
-> FStar.Pervasives.Lemma (requires LowParse.Spec.Combinators.synth_inverse g f)
(ensures LowParse.Spec.Combinators.synth_injective f)
[SMTPat (LowParse.Spec.Combinators.synth_inverse g f)] | {
"end_col": 62,
"end_line": 730,
"start_col": 2,
"start_line": 730
} |
Prims.GTot | val bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t -> Tot parser_kind))
(p: (t: tag_t -> Tot (parser (k' t) (refine_with_tag tag_of_data t))))
(input: bytes)
: GTot (option (data_t * consumed_length input)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end | val bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t -> Tot parser_kind))
(p: (t: tag_t -> Tot (parser (k' t) (refine_with_tag tag_of_data t))))
(input: bytes)
: GTot (option (data_t * consumed_length input))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t -> Tot parser_kind))
(p: (t: tag_t -> Tot (parser (k' t) (refine_with_tag tag_of_data t))))
(input: bytes)
: GTot (option (data_t * consumed_length input)) = | false | null | false | match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"sometrivial"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.refine_with_tag",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"Prims.op_Addition",
"FStar.Pervasives.Native.option",
"FStar.Seq.Base.seq",
"LowParse.Bytes.byte",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.length"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t -> Tot parser_kind))
(p: (t: tag_t -> Tot (parser (k' t) (refine_with_tag tag_of_data t))))
(input: bytes)
: GTot (option (data_t * consumed_length input)) | [] | LowParse.Spec.Combinators.bare_parse_tagged_union | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
pt: LowParse.Spec.Base.parser kt tag_t ->
tag_of_data: (_: data_t -> Prims.GTot tag_t) ->
k': (t: tag_t -> LowParse.Spec.Base.parser_kind) ->
p:
(t: tag_t
-> LowParse.Spec.Base.parser (k' t) (LowParse.Spec.Base.refine_with_tag tag_of_data t)) ->
input: LowParse.Bytes.bytes
-> Prims.GTot (FStar.Pervasives.Native.option (data_t * LowParse.Spec.Base.consumed_length input)) | {
"end_col": 7,
"end_line": 974,
"start_col": 2,
"start_line": 967
} |
FStar.Pervasives.Lemma | val parse_synth_eq2
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma (ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b | val parse_synth_eq2
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma (ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma (ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b)) = | false | null | true | parse_synth_eq p1 f2 b | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"Prims.squash",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.Bytes.bytes",
"LowParse.Spec.Combinators.parse_synth_eq",
"Prims.unit",
"Prims.l_True",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.Combinators.parse_synth'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val parse_synth_eq2
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma (ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b)) | [] | LowParse.Spec.Combinators.parse_synth_eq2 | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p1: LowParse.Spec.Base.parser k t1 ->
f2: (_: t1 -> Prims.GTot t2) ->
sq: Prims.squash (LowParse.Spec.Combinators.synth_injective f2) ->
b: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Base.parse (LowParse.Spec.Combinators.parse_synth p1 f2) b ==
LowParse.Spec.Combinators.parse_synth' p1 f2 b) | {
"end_col": 24,
"end_line": 639,
"start_col": 2,
"start_line": 639
} |
Prims.Tot | val bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1{p2 x})) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1 { p2 x } ))
= fun (xbytes: bytes) ->
match parse p1 xbytes with
| Some (x, consumed) ->
prf xbytes consumed x;
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None | val bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1{p2 x}))
let bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1{p2 x})) = | false | null | false | fun (xbytes: bytes) ->
match parse p1 xbytes with
| Some (x, consumed) ->
prf xbytes consumed x;
let x':x': t1{p2 x'} = x in
Some (x', consumed)
| _ -> None | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Combinators.parse_strengthen_prf",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Base.consumed_length",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"Prims.unit",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.None",
"LowParse.Spec.Base.bare_parser"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2)
val serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
: Tot (serializer (nondep_then p1 p2))
val serialize_nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input: t1 * t2)
: Lemma
(serialize (serialize_nondep_then s1 s2) input == bare_serialize_nondep_then p1 s1 p2 s2 input)
val length_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input1: t1)
(input2: t2)
: Lemma
(Seq.length (serialize (serialize_nondep_then s1 s2) (input1, input2)) == Seq.length (serialize s1 input1) + Seq.length (serialize s2 input2))
val serialize_nondep_then_upd_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s 0 (serialize s1 y)
))
val serialize_nondep_then_upd_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s i' s'
))
val serialize_nondep_then_upd_bw_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s len2 (serialize s1 y)
))
#reset-options "--z3refresh --z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val serialize_nondep_then_upd_bw_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_bw_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s (len2 + i') s'
))
val serialize_nondep_then_upd_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (Seq.length s - Seq.length (serialize s2 y)) (serialize s2 y)
))
val serialize_nondep_then_upd_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
l1 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (l1 + i') s'
))
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y)
))
= serialize_nondep_then_upd_right s1 s2 x y
let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_bw_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s'
))
= let s2' = serialize s2 (snd x) in
let j' = Seq.length s2' - i' - Seq.length s' in
assert (j' + Seq.length s' <= Seq.length s2');
assert (serialize s2 y == seq_upd_seq s2' j' s');
let s = serialize (serialize_nondep_then s1 s2) x in
serialize_nondep_then_upd_right_chain s1 s2 x y j' s';
assert (Seq.length (serialize s1 (fst x)) + j' == Seq.length s - i' - Seq.length s');
()
#reset-options "--z3rlimit 32 --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Apply a total transformation on parsed data *)
let parse_strengthen_prf
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
: Tot Type
= (xbytes: bytes) ->
(consumed: consumed_length xbytes) ->
(x: t1) ->
Lemma
(requires (parse p1 xbytes == Some (x, consumed)))
(ensures (p2 x))
let bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2) | false | false | LowParse.Spec.Combinators.fsti | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1{p2 x})) | [] | LowParse.Spec.Combinators.bare_parse_strengthen | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p1: LowParse.Spec.Base.parser k t1 ->
p2: (_: t1 -> Prims.GTot Type0) ->
prf: LowParse.Spec.Combinators.parse_strengthen_prf p1 p2
-> LowParse.Spec.Base.bare_parser (x: t1{p2 x}) | {
"end_col": 13,
"end_line": 1632,
"start_col": 2,
"start_line": 1626
} |
Prims.Tot | val parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Tot (parser k (x: t1{p2 x})) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser k (x: t1 { p2 x } ))
= bare_parse_strengthen_correct p1 p2 prf;
bare_parse_strengthen p1 p2 prf | val parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Tot (parser k (x: t1{p2 x}))
let parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Tot (parser k (x: t1{p2 x})) = | false | null | false | bare_parse_strengthen_correct p1 p2 prf;
bare_parse_strengthen p1 p2 prf | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Combinators.parse_strengthen_prf",
"LowParse.Spec.Combinators.bare_parse_strengthen",
"Prims.unit",
"LowParse.Spec.Combinators.bare_parse_strengthen_correct"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2)
val serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
: Tot (serializer (nondep_then p1 p2))
val serialize_nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input: t1 * t2)
: Lemma
(serialize (serialize_nondep_then s1 s2) input == bare_serialize_nondep_then p1 s1 p2 s2 input)
val length_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input1: t1)
(input2: t2)
: Lemma
(Seq.length (serialize (serialize_nondep_then s1 s2) (input1, input2)) == Seq.length (serialize s1 input1) + Seq.length (serialize s2 input2))
val serialize_nondep_then_upd_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s 0 (serialize s1 y)
))
val serialize_nondep_then_upd_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s i' s'
))
val serialize_nondep_then_upd_bw_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s len2 (serialize s1 y)
))
#reset-options "--z3refresh --z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val serialize_nondep_then_upd_bw_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_bw_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s (len2 + i') s'
))
val serialize_nondep_then_upd_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (Seq.length s - Seq.length (serialize s2 y)) (serialize s2 y)
))
val serialize_nondep_then_upd_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
l1 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (l1 + i') s'
))
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y)
))
= serialize_nondep_then_upd_right s1 s2 x y
let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_bw_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s'
))
= let s2' = serialize s2 (snd x) in
let j' = Seq.length s2' - i' - Seq.length s' in
assert (j' + Seq.length s' <= Seq.length s2');
assert (serialize s2 y == seq_upd_seq s2' j' s');
let s = serialize (serialize_nondep_then s1 s2) x in
serialize_nondep_then_upd_right_chain s1 s2 x y j' s';
assert (Seq.length (serialize s1 (fst x)) + j' == Seq.length s - i' - Seq.length s');
()
#reset-options "--z3rlimit 32 --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Apply a total transformation on parsed data *)
let parse_strengthen_prf
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
: Tot Type
= (xbytes: bytes) ->
(consumed: consumed_length xbytes) ->
(x: t1) ->
Lemma
(requires (parse p1 xbytes == Some (x, consumed)))
(ensures (p2 x))
let bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1 { p2 x } ))
= fun (xbytes: bytes) ->
match parse p1 xbytes with
| Some (x, consumed) ->
prf xbytes consumed x;
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
let bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf))
= let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . no_lookahead_on p1 b1 b2 ==> no_lookahead_on p' b1 b2)
let bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . injective_precond p' b1 b2 ==> injective_precond p1 b1 b2);
assert (forall (b1 b2: bytes) . injective_postcond p1 b1 b2 ==> injective_postcond p' b1 b2)
let bare_parse_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf) /\
parser_kind_prop k (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
bare_parse_strengthen_no_lookahead p1 p2 prf;
bare_parse_strengthen_injective p1 p2 prf;
parser_kind_prop_equiv k (bare_parse_strengthen p1 p2 prf);
()
let parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2) | false | false | LowParse.Spec.Combinators.fsti | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Tot (parser k (x: t1{p2 x})) | [] | LowParse.Spec.Combinators.parse_strengthen | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p1: LowParse.Spec.Base.parser k t1 ->
p2: (_: t1 -> Prims.GTot Type0) ->
prf: LowParse.Spec.Combinators.parse_strengthen_prf p1 p2
-> LowParse.Spec.Base.parser k (x: t1{p2 x}) | {
"end_col": 33,
"end_line": 1681,
"start_col": 2,
"start_line": 1680
} |
Prims.Tot | val synth_dtuple2_recip
(#t1: Type)
(#t2: (t1 -> Type))
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y | val synth_dtuple2_recip
(#t1: Type)
(#t2: (t1 -> Type))
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
let synth_dtuple2_recip
(#t1: Type)
(#t2: (t1 -> Type))
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x) = | false | null | false | dsnd y | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.refine_with_tag",
"Prims.dtuple2",
"FStar.Pervasives.dfst",
"FStar.Pervasives.dsnd"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val synth_dtuple2_recip
(#t1: Type)
(#t2: (t1 -> Type))
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x) | [] | LowParse.Spec.Combinators.synth_dtuple2_recip | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: t1 -> y: LowParse.Spec.Base.refine_with_tag FStar.Pervasives.dfst x -> t2 x | {
"end_col": 8,
"end_line": 1206,
"start_col": 2,
"start_line": 1206
} |
FStar.Pervasives.Lemma | val parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1 -> parser k2 (t2 x)))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b | val parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1 -> parser k2 (t2 x)))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1 -> parser k2 (t2 x)))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b) = | false | null | true | parse_dtuple2_eq p1 p2 b | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Bytes.bytes",
"LowParse.Spec.Combinators.parse_dtuple2_eq",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"Prims.dtuple2",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Combinators.parse_dtuple2",
"LowParse.Spec.Combinators.bare_parse_dtuple2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1 -> parser k2 (t2 x)))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b) | [] | LowParse.Spec.Combinators.parse_dtuple2_eq' | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p1: LowParse.Spec.Base.parser k1 t1 ->
p2: (x: t1 -> LowParse.Spec.Base.parser k2 (t2 x)) ->
b: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Base.parse (LowParse.Spec.Combinators.parse_dtuple2 p1 p2) b ==
LowParse.Spec.Combinators.bare_parse_dtuple2 p1 p2 b) | {
"end_col": 26,
"end_line": 1268,
"start_col": 2,
"start_line": 1268
} |
Prims.Tot | val serialize_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
: Tot (serializer (parse_strengthen p1 p2 prf)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let serialize_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
: Tot (serializer (parse_strengthen p1 p2 prf))
= Classical.forall_intro (serialize_strengthen_correct p2 prf s);
serialize_strengthen' p2 prf s | val serialize_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
: Tot (serializer (parse_strengthen p1 p2 prf))
let serialize_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
: Tot (serializer (parse_strengthen p1 p2 prf)) = | false | null | false | Classical.forall_intro (serialize_strengthen_correct p2 prf s);
serialize_strengthen' p2 prf s | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Combinators.parse_strengthen_prf",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.Combinators.serialize_strengthen'",
"Prims.unit",
"FStar.Classical.forall_intro",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Combinators.parse_strengthen",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Spec.Combinators.serialize_strengthen_correct"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2)
val serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
: Tot (serializer (nondep_then p1 p2))
val serialize_nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input: t1 * t2)
: Lemma
(serialize (serialize_nondep_then s1 s2) input == bare_serialize_nondep_then p1 s1 p2 s2 input)
val length_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input1: t1)
(input2: t2)
: Lemma
(Seq.length (serialize (serialize_nondep_then s1 s2) (input1, input2)) == Seq.length (serialize s1 input1) + Seq.length (serialize s2 input2))
val serialize_nondep_then_upd_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s 0 (serialize s1 y)
))
val serialize_nondep_then_upd_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s i' s'
))
val serialize_nondep_then_upd_bw_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s len2 (serialize s1 y)
))
#reset-options "--z3refresh --z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val serialize_nondep_then_upd_bw_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_bw_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s (len2 + i') s'
))
val serialize_nondep_then_upd_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (Seq.length s - Seq.length (serialize s2 y)) (serialize s2 y)
))
val serialize_nondep_then_upd_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
l1 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (l1 + i') s'
))
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y)
))
= serialize_nondep_then_upd_right s1 s2 x y
let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_bw_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s'
))
= let s2' = serialize s2 (snd x) in
let j' = Seq.length s2' - i' - Seq.length s' in
assert (j' + Seq.length s' <= Seq.length s2');
assert (serialize s2 y == seq_upd_seq s2' j' s');
let s = serialize (serialize_nondep_then s1 s2) x in
serialize_nondep_then_upd_right_chain s1 s2 x y j' s';
assert (Seq.length (serialize s1 (fst x)) + j' == Seq.length s - i' - Seq.length s');
()
#reset-options "--z3rlimit 32 --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Apply a total transformation on parsed data *)
let parse_strengthen_prf
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
: Tot Type
= (xbytes: bytes) ->
(consumed: consumed_length xbytes) ->
(x: t1) ->
Lemma
(requires (parse p1 xbytes == Some (x, consumed)))
(ensures (p2 x))
let bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1 { p2 x } ))
= fun (xbytes: bytes) ->
match parse p1 xbytes with
| Some (x, consumed) ->
prf xbytes consumed x;
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
let bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf))
= let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . no_lookahead_on p1 b1 b2 ==> no_lookahead_on p' b1 b2)
let bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . injective_precond p' b1 b2 ==> injective_precond p1 b1 b2);
assert (forall (b1 b2: bytes) . injective_postcond p1 b1 b2 ==> injective_postcond p' b1 b2)
let bare_parse_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf) /\
parser_kind_prop k (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
bare_parse_strengthen_no_lookahead p1 p2 prf;
bare_parse_strengthen_injective p1 p2 prf;
parser_kind_prop_equiv k (bare_parse_strengthen p1 p2 prf);
()
let parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser k (x: t1 { p2 x } ))
= bare_parse_strengthen_correct p1 p2 prf;
bare_parse_strengthen p1 p2 prf
let serialize_strengthen'
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: GTot bytes
= serialize s input
let serialize_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: Lemma
(let output = serialize_strengthen' p2 prf s input in
parse (parse_strengthen p1 p2 prf) output == Some (input, Seq.length output))
= ()
let serialize_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1) | false | false | LowParse.Spec.Combinators.fsti | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
: Tot (serializer (parse_strengthen p1 p2 prf)) | [] | LowParse.Spec.Combinators.serialize_strengthen | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p2: (_: t1 -> Prims.GTot Type0) ->
prf: LowParse.Spec.Combinators.parse_strengthen_prf p1 p2 ->
s: LowParse.Spec.Base.serializer p1
-> LowParse.Spec.Base.serializer (LowParse.Spec.Combinators.parse_strengthen p1 p2 prf) | {
"end_col": 32,
"end_line": 1716,
"start_col": 2,
"start_line": 1715
} |
FStar.Pervasives.Lemma | val bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Lemma (no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf))
= let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . no_lookahead_on p1 b1 b2 ==> no_lookahead_on p' b1 b2) | val bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Lemma (no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf))
let bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Lemma (no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf)) = | false | null | true | let p':bare_parser (x: t1{p2 x}) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1: bytes) (b2: bytes). no_lookahead_on p1 b1 b2 ==> no_lookahead_on p' b1 b2) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Combinators.parse_strengthen_prf",
"Prims._assert",
"Prims.l_Forall",
"LowParse.Bytes.bytes",
"Prims.l_imp",
"LowParse.Spec.Base.no_lookahead_on",
"LowParse.Spec.Base.bare_parser",
"LowParse.Spec.Combinators.bare_parse_strengthen",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"LowParse.Spec.Base.no_lookahead",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2)
val serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
: Tot (serializer (nondep_then p1 p2))
val serialize_nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input: t1 * t2)
: Lemma
(serialize (serialize_nondep_then s1 s2) input == bare_serialize_nondep_then p1 s1 p2 s2 input)
val length_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input1: t1)
(input2: t2)
: Lemma
(Seq.length (serialize (serialize_nondep_then s1 s2) (input1, input2)) == Seq.length (serialize s1 input1) + Seq.length (serialize s2 input2))
val serialize_nondep_then_upd_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s 0 (serialize s1 y)
))
val serialize_nondep_then_upd_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s i' s'
))
val serialize_nondep_then_upd_bw_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s len2 (serialize s1 y)
))
#reset-options "--z3refresh --z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val serialize_nondep_then_upd_bw_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_bw_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s (len2 + i') s'
))
val serialize_nondep_then_upd_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (Seq.length s - Seq.length (serialize s2 y)) (serialize s2 y)
))
val serialize_nondep_then_upd_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
l1 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (l1 + i') s'
))
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y)
))
= serialize_nondep_then_upd_right s1 s2 x y
let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_bw_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s'
))
= let s2' = serialize s2 (snd x) in
let j' = Seq.length s2' - i' - Seq.length s' in
assert (j' + Seq.length s' <= Seq.length s2');
assert (serialize s2 y == seq_upd_seq s2' j' s');
let s = serialize (serialize_nondep_then s1 s2) x in
serialize_nondep_then_upd_right_chain s1 s2 x y j' s';
assert (Seq.length (serialize s1 (fst x)) + j' == Seq.length s - i' - Seq.length s');
()
#reset-options "--z3rlimit 32 --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Apply a total transformation on parsed data *)
let parse_strengthen_prf
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
: Tot Type
= (xbytes: bytes) ->
(consumed: consumed_length xbytes) ->
(x: t1) ->
Lemma
(requires (parse p1 xbytes == Some (x, consumed)))
(ensures (p2 x))
let bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1 { p2 x } ))
= fun (xbytes: bytes) ->
match parse p1 xbytes with
| Some (x, consumed) ->
prf xbytes consumed x;
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
let bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma | false | false | LowParse.Spec.Combinators.fsti | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Lemma (no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf)) | [] | LowParse.Spec.Combinators.bare_parse_strengthen_no_lookahead | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p1: LowParse.Spec.Base.parser k t1 ->
p2: (_: t1 -> Prims.GTot Type0) ->
prf: LowParse.Spec.Combinators.parse_strengthen_prf p1 p2
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Base.no_lookahead p1 ==>
LowParse.Spec.Base.no_lookahead (LowParse.Spec.Combinators.bare_parse_strengthen p1 p2 prf)) | {
"end_col": 88,
"end_line": 1643,
"start_col": 1,
"start_line": 1642
} |
FStar.Pervasives.Lemma | val parse_tagged_union_payload_and_then_cases_injective
(#tag_t #data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
: Lemma (and_then_cases_injective (parse_tagged_union_payload tag_of_data p)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
) | val parse_tagged_union_payload_and_then_cases_injective
(#tag_t #data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
: Lemma (and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t #data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
: Lemma (and_then_cases_injective (parse_tagged_union_payload tag_of_data p)) = | false | null | true | and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p)
(fun x1 x2 b1 b2 ->
parse_synth_eq #k
#(refine_with_tag tag_of_data x1)
(p x1)
(synth_tagged_union_data tag_of_data x1)
b1;
parse_synth_eq #k
#(refine_with_tag tag_of_data x2)
(p x2)
(synth_tagged_union_data tag_of_data x2)
b2) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.refine_with_tag",
"LowParse.Spec.Combinators.and_then_cases_injective_intro",
"LowParse.Spec.Combinators.parse_tagged_union_payload",
"LowParse.Bytes.bytes",
"LowParse.Spec.Combinators.parse_synth_eq",
"LowParse.Spec.Combinators.synth_tagged_union_data",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"LowParse.Spec.Combinators.and_then_cases_injective",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val parse_tagged_union_payload_and_then_cases_injective
(#tag_t #data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
: Lemma (and_then_cases_injective (parse_tagged_union_payload tag_of_data p)) | [] | LowParse.Spec.Combinators.parse_tagged_union_payload_and_then_cases_injective | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
tag_of_data: (_: data_t -> Prims.GTot tag_t) ->
p: (t: tag_t -> LowParse.Spec.Base.parser k (LowParse.Spec.Base.refine_with_tag tag_of_data t))
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Combinators.and_then_cases_injective (LowParse.Spec.Combinators.parse_tagged_union_payload
tag_of_data
p)) | {
"end_col": 3,
"end_line": 925,
"start_col": 2,
"start_line": 922
} |
FStar.Pervasives.Lemma | val lift_parser_correct (#k: parser_kind) (#t: Type) (f: (unit -> GTot (parser k t)))
: Lemma (parser_kind_prop k (lift_parser' f)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let lift_parser_correct
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Lemma
(parser_kind_prop k (lift_parser' f))
= parser_kind_prop_ext k (f ()) (lift_parser' f) | val lift_parser_correct (#k: parser_kind) (#t: Type) (f: (unit -> GTot (parser k t)))
: Lemma (parser_kind_prop k (lift_parser' f))
let lift_parser_correct (#k: parser_kind) (#t: Type) (f: (unit -> GTot (parser k t)))
: Lemma (parser_kind_prop k (lift_parser' f)) = | false | null | true | parser_kind_prop_ext k (f ()) (lift_parser' f) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"Prims.unit",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.parser_kind_prop_ext",
"LowParse.Spec.Combinators.lift_parser'",
"Prims.l_True",
"Prims.squash",
"LowParse.Spec.Base.parser_kind_prop",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2)
val serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
: Tot (serializer (nondep_then p1 p2))
val serialize_nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input: t1 * t2)
: Lemma
(serialize (serialize_nondep_then s1 s2) input == bare_serialize_nondep_then p1 s1 p2 s2 input)
val length_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input1: t1)
(input2: t2)
: Lemma
(Seq.length (serialize (serialize_nondep_then s1 s2) (input1, input2)) == Seq.length (serialize s1 input1) + Seq.length (serialize s2 input2))
val serialize_nondep_then_upd_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s 0 (serialize s1 y)
))
val serialize_nondep_then_upd_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s i' s'
))
val serialize_nondep_then_upd_bw_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s len2 (serialize s1 y)
))
#reset-options "--z3refresh --z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val serialize_nondep_then_upd_bw_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_bw_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s (len2 + i') s'
))
val serialize_nondep_then_upd_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (Seq.length s - Seq.length (serialize s2 y)) (serialize s2 y)
))
val serialize_nondep_then_upd_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
l1 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (l1 + i') s'
))
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y)
))
= serialize_nondep_then_upd_right s1 s2 x y
let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_bw_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s'
))
= let s2' = serialize s2 (snd x) in
let j' = Seq.length s2' - i' - Seq.length s' in
assert (j' + Seq.length s' <= Seq.length s2');
assert (serialize s2 y == seq_upd_seq s2' j' s');
let s = serialize (serialize_nondep_then s1 s2) x in
serialize_nondep_then_upd_right_chain s1 s2 x y j' s';
assert (Seq.length (serialize s1 (fst x)) + j' == Seq.length s - i' - Seq.length s');
()
#reset-options "--z3rlimit 32 --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Apply a total transformation on parsed data *)
let parse_strengthen_prf
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
: Tot Type
= (xbytes: bytes) ->
(consumed: consumed_length xbytes) ->
(x: t1) ->
Lemma
(requires (parse p1 xbytes == Some (x, consumed)))
(ensures (p2 x))
let bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1 { p2 x } ))
= fun (xbytes: bytes) ->
match parse p1 xbytes with
| Some (x, consumed) ->
prf xbytes consumed x;
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
let bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf))
= let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . no_lookahead_on p1 b1 b2 ==> no_lookahead_on p' b1 b2)
let bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . injective_precond p' b1 b2 ==> injective_precond p1 b1 b2);
assert (forall (b1 b2: bytes) . injective_postcond p1 b1 b2 ==> injective_postcond p' b1 b2)
let bare_parse_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf) /\
parser_kind_prop k (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
bare_parse_strengthen_no_lookahead p1 p2 prf;
bare_parse_strengthen_injective p1 p2 prf;
parser_kind_prop_equiv k (bare_parse_strengthen p1 p2 prf);
()
let parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser k (x: t1 { p2 x } ))
= bare_parse_strengthen_correct p1 p2 prf;
bare_parse_strengthen p1 p2 prf
let serialize_strengthen'
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: GTot bytes
= serialize s input
let serialize_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: Lemma
(let output = serialize_strengthen' p2 prf s input in
parse (parse_strengthen p1 p2 prf) output == Some (input, Seq.length output))
= ()
let serialize_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
: Tot (serializer (parse_strengthen p1 p2 prf))
= Classical.forall_intro (serialize_strengthen_correct p2 prf s);
serialize_strengthen' p2 prf s
let compose (#t1 #t2 #t3: Type) (f1: t1 -> GTot t2) (f2: t2 -> GTot t3) (x: t1) : GTot t3 =
let y1 = f1 x in
f2 y1
val make_total_constant_size_parser_compose
(sz: nat)
(t1 t2: Type)
(f1: ((s: bytes {Seq.length s == sz}) -> GTot t1))
(g2: t1 -> GTot t2)
: Lemma
(requires (
make_total_constant_size_parser_precond sz t1 f1 /\
(forall x x' . g2 x == g2 x' ==> x == x')
))
(ensures (
make_total_constant_size_parser_precond sz t1 f1 /\
make_total_constant_size_parser_precond sz t2 (f1 `compose` g2) /\
(forall x x' . {:pattern (g2 x); (g2 x')} g2 x == g2 x' ==> x == x') /\
(forall input . {:pattern (parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input)} parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input == parse (make_total_constant_size_parser sz t1 f1 `parse_synth` g2) input)
))
(** Tot vs. Ghost *)
unfold
let lift_parser'
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (bare_parser t)
= fun (input: bytes) -> parse (f ()) input
let lift_parser_correct
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Lemma | false | false | LowParse.Spec.Combinators.fsti | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lift_parser_correct (#k: parser_kind) (#t: Type) (f: (unit -> GTot (parser k t)))
: Lemma (parser_kind_prop k (lift_parser' f)) | [] | LowParse.Spec.Combinators.lift_parser_correct | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | f: (_: Prims.unit -> Prims.GTot (LowParse.Spec.Base.parser k t))
-> FStar.Pervasives.Lemma
(ensures LowParse.Spec.Base.parser_kind_prop k (LowParse.Spec.Combinators.lift_parser' f)) | {
"end_col": 48,
"end_line": 1755,
"start_col": 2,
"start_line": 1755
} |
Prims.Tot | val parse_filter_kind (k: parser_kind) : Tot parser_kind | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let parse_filter_kind (k: parser_kind) : Tot parser_kind =
{
parser_kind_low = k.parser_kind_low;
parser_kind_high = k.parser_kind_high;
parser_kind_metadata =
begin match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
end;
parser_kind_subkind = k.parser_kind_subkind;
} | val parse_filter_kind (k: parser_kind) : Tot parser_kind
let parse_filter_kind (k: parser_kind) : Tot parser_kind = | false | null | false | {
parser_kind_low = k.parser_kind_low;
parser_kind_high = k.parser_kind_high;
parser_kind_metadata
=
(match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None);
parser_kind_subkind = k.parser_kind_subkind
} | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.Mkparser_kind'",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_metadata",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.parser_kind_metadata_some",
"LowParse.Spec.Base.ParserKindMetadataFail",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.None",
"LowParse.Spec.Base.parser_kind_metadata_t"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2)
val serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
: Tot (serializer (nondep_then p1 p2))
val serialize_nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input: t1 * t2)
: Lemma
(serialize (serialize_nondep_then s1 s2) input == bare_serialize_nondep_then p1 s1 p2 s2 input)
val length_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input1: t1)
(input2: t2)
: Lemma
(Seq.length (serialize (serialize_nondep_then s1 s2) (input1, input2)) == Seq.length (serialize s1 input1) + Seq.length (serialize s2 input2))
val serialize_nondep_then_upd_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s 0 (serialize s1 y)
))
val serialize_nondep_then_upd_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s i' s'
))
val serialize_nondep_then_upd_bw_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s len2 (serialize s1 y)
))
#reset-options "--z3refresh --z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val serialize_nondep_then_upd_bw_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_bw_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s (len2 + i') s'
))
val serialize_nondep_then_upd_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (Seq.length s - Seq.length (serialize s2 y)) (serialize s2 y)
))
val serialize_nondep_then_upd_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
l1 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (l1 + i') s'
))
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y)
))
= serialize_nondep_then_upd_right s1 s2 x y
let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_bw_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s'
))
= let s2' = serialize s2 (snd x) in
let j' = Seq.length s2' - i' - Seq.length s' in
assert (j' + Seq.length s' <= Seq.length s2');
assert (serialize s2 y == seq_upd_seq s2' j' s');
let s = serialize (serialize_nondep_then s1 s2) x in
serialize_nondep_then_upd_right_chain s1 s2 x y j' s';
assert (Seq.length (serialize s1 (fst x)) + j' == Seq.length s - i' - Seq.length s');
()
#reset-options "--z3rlimit 32 --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Apply a total transformation on parsed data *)
let parse_strengthen_prf
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
: Tot Type
= (xbytes: bytes) ->
(consumed: consumed_length xbytes) ->
(x: t1) ->
Lemma
(requires (parse p1 xbytes == Some (x, consumed)))
(ensures (p2 x))
let bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1 { p2 x } ))
= fun (xbytes: bytes) ->
match parse p1 xbytes with
| Some (x, consumed) ->
prf xbytes consumed x;
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
let bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf))
= let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . no_lookahead_on p1 b1 b2 ==> no_lookahead_on p' b1 b2)
let bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . injective_precond p' b1 b2 ==> injective_precond p1 b1 b2);
assert (forall (b1 b2: bytes) . injective_postcond p1 b1 b2 ==> injective_postcond p' b1 b2)
let bare_parse_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf) /\
parser_kind_prop k (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
bare_parse_strengthen_no_lookahead p1 p2 prf;
bare_parse_strengthen_injective p1 p2 prf;
parser_kind_prop_equiv k (bare_parse_strengthen p1 p2 prf);
()
let parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser k (x: t1 { p2 x } ))
= bare_parse_strengthen_correct p1 p2 prf;
bare_parse_strengthen p1 p2 prf
let serialize_strengthen'
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: GTot bytes
= serialize s input
let serialize_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: Lemma
(let output = serialize_strengthen' p2 prf s input in
parse (parse_strengthen p1 p2 prf) output == Some (input, Seq.length output))
= ()
let serialize_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
: Tot (serializer (parse_strengthen p1 p2 prf))
= Classical.forall_intro (serialize_strengthen_correct p2 prf s);
serialize_strengthen' p2 prf s
let compose (#t1 #t2 #t3: Type) (f1: t1 -> GTot t2) (f2: t2 -> GTot t3) (x: t1) : GTot t3 =
let y1 = f1 x in
f2 y1
val make_total_constant_size_parser_compose
(sz: nat)
(t1 t2: Type)
(f1: ((s: bytes {Seq.length s == sz}) -> GTot t1))
(g2: t1 -> GTot t2)
: Lemma
(requires (
make_total_constant_size_parser_precond sz t1 f1 /\
(forall x x' . g2 x == g2 x' ==> x == x')
))
(ensures (
make_total_constant_size_parser_precond sz t1 f1 /\
make_total_constant_size_parser_precond sz t2 (f1 `compose` g2) /\
(forall x x' . {:pattern (g2 x); (g2 x')} g2 x == g2 x' ==> x == x') /\
(forall input . {:pattern (parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input)} parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input == parse (make_total_constant_size_parser sz t1 f1 `parse_synth` g2) input)
))
(** Tot vs. Ghost *)
unfold
let lift_parser'
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (bare_parser t)
= fun (input: bytes) -> parse (f ()) input
let lift_parser_correct
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Lemma
(parser_kind_prop k (lift_parser' f))
= parser_kind_prop_ext k (f ()) (lift_parser' f)
let lift_parser
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (parser k t)
= lift_parser_correct f;
lift_parser' f
unfold
let lift_serializer'
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Tot (bare_serializer t)
= fun (x: t) -> serialize (s ()) x
let lift_serializer_correct
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Lemma
(serializer_correct (lift_parser f) (lift_serializer' s))
= ()
let lift_serializer
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Tot (serializer #k #t (lift_parser f))
= lift_serializer_correct #k #t #f s;
lift_serializer' #k #t #f s
(** Refinements *)
// unfold
inline_for_extraction
let parse_filter_kind (k: parser_kind) : Tot parser_kind = | false | true | LowParse.Spec.Combinators.fsti | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_filter_kind (k: parser_kind) : Tot parser_kind | [] | LowParse.Spec.Combinators.parse_filter_kind | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | k: LowParse.Spec.Base.parser_kind -> LowParse.Spec.Base.parser_kind | {
"end_col": 48,
"end_line": 1805,
"start_col": 4,
"start_line": 1798
} |
Prims.Tot | val serialize_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(f: (t -> GTot bool))
: Tot (serializer (parse_filter p f)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let serialize_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(f: (t -> GTot bool))
: Tot (serializer (parse_filter p f))
= serialize_filter_correct s f;
serialize_filter' s f | val serialize_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(f: (t -> GTot bool))
: Tot (serializer (parse_filter p f))
let serialize_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(f: (t -> GTot bool))
: Tot (serializer (parse_filter p f)) = | false | null | false | serialize_filter_correct s f;
serialize_filter' s f | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.bool",
"LowParse.Spec.Combinators.serialize_filter'",
"Prims.unit",
"LowParse.Spec.Combinators.serialize_filter_correct",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.Combinators.parse_filter"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2)
val serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
: Tot (serializer (nondep_then p1 p2))
val serialize_nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input: t1 * t2)
: Lemma
(serialize (serialize_nondep_then s1 s2) input == bare_serialize_nondep_then p1 s1 p2 s2 input)
val length_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input1: t1)
(input2: t2)
: Lemma
(Seq.length (serialize (serialize_nondep_then s1 s2) (input1, input2)) == Seq.length (serialize s1 input1) + Seq.length (serialize s2 input2))
val serialize_nondep_then_upd_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s 0 (serialize s1 y)
))
val serialize_nondep_then_upd_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s i' s'
))
val serialize_nondep_then_upd_bw_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s len2 (serialize s1 y)
))
#reset-options "--z3refresh --z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val serialize_nondep_then_upd_bw_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_bw_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s (len2 + i') s'
))
val serialize_nondep_then_upd_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (Seq.length s - Seq.length (serialize s2 y)) (serialize s2 y)
))
val serialize_nondep_then_upd_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
l1 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (l1 + i') s'
))
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y)
))
= serialize_nondep_then_upd_right s1 s2 x y
let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_bw_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s'
))
= let s2' = serialize s2 (snd x) in
let j' = Seq.length s2' - i' - Seq.length s' in
assert (j' + Seq.length s' <= Seq.length s2');
assert (serialize s2 y == seq_upd_seq s2' j' s');
let s = serialize (serialize_nondep_then s1 s2) x in
serialize_nondep_then_upd_right_chain s1 s2 x y j' s';
assert (Seq.length (serialize s1 (fst x)) + j' == Seq.length s - i' - Seq.length s');
()
#reset-options "--z3rlimit 32 --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Apply a total transformation on parsed data *)
let parse_strengthen_prf
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
: Tot Type
= (xbytes: bytes) ->
(consumed: consumed_length xbytes) ->
(x: t1) ->
Lemma
(requires (parse p1 xbytes == Some (x, consumed)))
(ensures (p2 x))
let bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1 { p2 x } ))
= fun (xbytes: bytes) ->
match parse p1 xbytes with
| Some (x, consumed) ->
prf xbytes consumed x;
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
let bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf))
= let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . no_lookahead_on p1 b1 b2 ==> no_lookahead_on p' b1 b2)
let bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . injective_precond p' b1 b2 ==> injective_precond p1 b1 b2);
assert (forall (b1 b2: bytes) . injective_postcond p1 b1 b2 ==> injective_postcond p' b1 b2)
let bare_parse_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf) /\
parser_kind_prop k (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
bare_parse_strengthen_no_lookahead p1 p2 prf;
bare_parse_strengthen_injective p1 p2 prf;
parser_kind_prop_equiv k (bare_parse_strengthen p1 p2 prf);
()
let parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser k (x: t1 { p2 x } ))
= bare_parse_strengthen_correct p1 p2 prf;
bare_parse_strengthen p1 p2 prf
let serialize_strengthen'
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: GTot bytes
= serialize s input
let serialize_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: Lemma
(let output = serialize_strengthen' p2 prf s input in
parse (parse_strengthen p1 p2 prf) output == Some (input, Seq.length output))
= ()
let serialize_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
: Tot (serializer (parse_strengthen p1 p2 prf))
= Classical.forall_intro (serialize_strengthen_correct p2 prf s);
serialize_strengthen' p2 prf s
let compose (#t1 #t2 #t3: Type) (f1: t1 -> GTot t2) (f2: t2 -> GTot t3) (x: t1) : GTot t3 =
let y1 = f1 x in
f2 y1
val make_total_constant_size_parser_compose
(sz: nat)
(t1 t2: Type)
(f1: ((s: bytes {Seq.length s == sz}) -> GTot t1))
(g2: t1 -> GTot t2)
: Lemma
(requires (
make_total_constant_size_parser_precond sz t1 f1 /\
(forall x x' . g2 x == g2 x' ==> x == x')
))
(ensures (
make_total_constant_size_parser_precond sz t1 f1 /\
make_total_constant_size_parser_precond sz t2 (f1 `compose` g2) /\
(forall x x' . {:pattern (g2 x); (g2 x')} g2 x == g2 x' ==> x == x') /\
(forall input . {:pattern (parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input)} parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input == parse (make_total_constant_size_parser sz t1 f1 `parse_synth` g2) input)
))
(** Tot vs. Ghost *)
unfold
let lift_parser'
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (bare_parser t)
= fun (input: bytes) -> parse (f ()) input
let lift_parser_correct
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Lemma
(parser_kind_prop k (lift_parser' f))
= parser_kind_prop_ext k (f ()) (lift_parser' f)
let lift_parser
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (parser k t)
= lift_parser_correct f;
lift_parser' f
unfold
let lift_serializer'
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Tot (bare_serializer t)
= fun (x: t) -> serialize (s ()) x
let lift_serializer_correct
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Lemma
(serializer_correct (lift_parser f) (lift_serializer' s))
= ()
let lift_serializer
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Tot (serializer #k #t (lift_parser f))
= lift_serializer_correct #k #t #f s;
lift_serializer' #k #t #f s
(** Refinements *)
// unfold
inline_for_extraction
let parse_filter_kind (k: parser_kind) : Tot parser_kind =
{
parser_kind_low = k.parser_kind_low;
parser_kind_high = k.parser_kind_high;
parser_kind_metadata =
begin match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
end;
parser_kind_subkind = k.parser_kind_subkind;
}
// unfold
let parse_filter_payload_kind : parser_kind =
strong_parser_kind 0 0 None
let parse_filter_refine (#t: Type) (f: (t -> GTot bool)) =
(x: t { f x == true } )
let parse_filter_payload
(#t: Type)
(f: (t -> GTot bool))
(v: t)
: Tot (parser parse_filter_payload_kind (parse_filter_refine f))
= let p = lift_parser (fun () ->
if f v
then
let v' : (x: t { f x == true } ) = v in
weaken parse_filter_payload_kind (parse_ret v')
else fail_parser parse_filter_payload_kind (parse_filter_refine f)
)
in
parser_kind_prop_equiv parse_filter_payload_kind p;
p
val parse_filter
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
: Tot (parser (parse_filter_kind k) (parse_filter_refine f))
val parse_filter_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: bytes)
: Lemma
(parse (parse_filter p f) input == (match parse p input with
| None -> None
| Some (x, consumed) ->
if f x
then Some (x, consumed)
else None
))
val tot_parse_filter
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(f: (t -> Tot bool))
: Pure (tot_parser (parse_filter_kind k) (parse_filter_refine f))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_filter #k p f) x
))
let tot_parse_filter_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(f: (t -> Tot bool))
(input: bytes)
: Lemma
(parse (tot_parse_filter p f) input == (match parse p input with
| None -> None
| Some (x, consumed) ->
if f x
then Some (x, consumed)
else None
))
= parse_filter_eq #k p f input
let serialize_filter'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(f: (t -> GTot bool))
: Tot (bare_serializer (x: t { f x == true } ))
= fun (input: t { f input == true } ) -> s input
val serialize_filter_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(f: (t -> GTot bool))
: Lemma
(serializer_correct (parse_filter p f) (serialize_filter' s f))
let serialize_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(f: (t -> GTot bool)) | false | false | LowParse.Spec.Combinators.fsti | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(f: (t -> GTot bool))
: Tot (serializer (parse_filter p f)) | [] | LowParse.Spec.Combinators.serialize_filter | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | s: LowParse.Spec.Base.serializer p -> f: (_: t -> Prims.GTot Prims.bool)
-> LowParse.Spec.Base.serializer (LowParse.Spec.Combinators.parse_filter p f) | {
"end_col": 23,
"end_line": 1906,
"start_col": 2,
"start_line": 1905
} |
FStar.Pervasives.Lemma | val bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(s: (t: tag_t -> Tot (serializer (p t))))
: Lemma (requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures
(serializer_correct (parse_tagged_union pt tag_of_data p)
(bare_serialize_tagged_union st tag_of_data s))) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf | val bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(s: (t: tag_t -> Tot (serializer (p t))))
: Lemma (requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures
(serializer_correct (parse_tagged_union pt tag_of_data p)
(bare_serialize_tagged_union st tag_of_data s)))
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(s: (t: tag_t -> Tot (serializer (p t))))
: Lemma (requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures
(serializer_correct (parse_tagged_union pt tag_of_data p)
(bare_serialize_tagged_union st tag_of_data s))) = | false | null | true | let prf (x: data_t)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) ==
Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x))) =
parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let u:refine_with_tag tag_of_data t = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let Some (_, len') = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt
(serialize st t)
(bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt
(serialize st t)
(bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let Some (x1, len1) = v1 in
let Some (x1', len1') = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x ==
Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.Base.refine_with_tag",
"FStar.Classical.forall_intro",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Combinators.bare_serialize_tagged_union",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Combinators.parse_tagged_union",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"LowParse.Spec.Base.serialize",
"LowParse.Spec.Combinators.seq_slice_append_r",
"Prims._assert",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.append",
"Prims.nat",
"LowParse.Spec.Base.injective_postcond",
"LowParse.Spec.Base.injective_precond",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"LowParse.Spec.Base.no_lookahead_on_postcond",
"LowParse.Spec.Base.no_lookahead_on_precond",
"LowParse.Spec.Combinators.seq_slice_append_l",
"FStar.Seq.Base.slice",
"Prims.op_LessThanOrEqual",
"LowParse.Spec.Base.no_lookahead_on",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"LowParse.Spec.Combinators.parse_tagged_union_eq",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Spec.Base.serializer_correct",
"LowParse.Spec.Combinators.and_then_kind"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong)) | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(s: (t: tag_t -> Tot (serializer (p t))))
: Lemma (requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures
(serializer_correct (parse_tagged_union pt tag_of_data p)
(bare_serialize_tagged_union st tag_of_data s))) | [] | LowParse.Spec.Combinators.bare_serialize_tagged_union_correct | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
st: LowParse.Spec.Base.serializer pt ->
tag_of_data: (_: data_t -> Prims.GTot tag_t) ->
s: (t: tag_t -> LowParse.Spec.Base.serializer (p t))
-> FStar.Pervasives.Lemma
(requires
Mkparser_kind'?.parser_kind_subkind kt ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong)
(ensures
LowParse.Spec.Base.serializer_correct (LowParse.Spec.Combinators.parse_tagged_union pt
tag_of_data
p)
(LowParse.Spec.Combinators.bare_serialize_tagged_union st tag_of_data s)) | {
"end_col": 28,
"end_line": 1126,
"start_col": 1,
"start_line": 1094
} |
FStar.Pervasives.Lemma | val bare_parse_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf) /\
parser_kind_prop k (bare_parse_strengthen p1 p2 prf)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let bare_parse_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf) /\
parser_kind_prop k (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
bare_parse_strengthen_no_lookahead p1 p2 prf;
bare_parse_strengthen_injective p1 p2 prf;
parser_kind_prop_equiv k (bare_parse_strengthen p1 p2 prf);
() | val bare_parse_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf) /\
parser_kind_prop k (bare_parse_strengthen p1 p2 prf))
let bare_parse_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf) /\
parser_kind_prop k (bare_parse_strengthen p1 p2 prf)) = | false | null | true | parser_kind_prop_equiv k p1;
bare_parse_strengthen_no_lookahead p1 p2 prf;
bare_parse_strengthen_injective p1 p2 prf;
parser_kind_prop_equiv k (bare_parse_strengthen p1 p2 prf);
() | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Combinators.parse_strengthen_prf",
"Prims.unit",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"LowParse.Spec.Combinators.bare_parse_strengthen",
"LowParse.Spec.Combinators.bare_parse_strengthen_injective",
"LowParse.Spec.Combinators.bare_parse_strengthen_no_lookahead",
"Prims.l_True",
"Prims.squash",
"Prims.l_and",
"LowParse.Spec.Base.injective",
"LowParse.Spec.Base.parser_kind_prop",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2)
val serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
: Tot (serializer (nondep_then p1 p2))
val serialize_nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input: t1 * t2)
: Lemma
(serialize (serialize_nondep_then s1 s2) input == bare_serialize_nondep_then p1 s1 p2 s2 input)
val length_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input1: t1)
(input2: t2)
: Lemma
(Seq.length (serialize (serialize_nondep_then s1 s2) (input1, input2)) == Seq.length (serialize s1 input1) + Seq.length (serialize s2 input2))
val serialize_nondep_then_upd_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s 0 (serialize s1 y)
))
val serialize_nondep_then_upd_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s i' s'
))
val serialize_nondep_then_upd_bw_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s len2 (serialize s1 y)
))
#reset-options "--z3refresh --z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val serialize_nondep_then_upd_bw_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_bw_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s (len2 + i') s'
))
val serialize_nondep_then_upd_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (Seq.length s - Seq.length (serialize s2 y)) (serialize s2 y)
))
val serialize_nondep_then_upd_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
l1 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (l1 + i') s'
))
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y)
))
= serialize_nondep_then_upd_right s1 s2 x y
let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_bw_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s'
))
= let s2' = serialize s2 (snd x) in
let j' = Seq.length s2' - i' - Seq.length s' in
assert (j' + Seq.length s' <= Seq.length s2');
assert (serialize s2 y == seq_upd_seq s2' j' s');
let s = serialize (serialize_nondep_then s1 s2) x in
serialize_nondep_then_upd_right_chain s1 s2 x y j' s';
assert (Seq.length (serialize s1 (fst x)) + j' == Seq.length s - i' - Seq.length s');
()
#reset-options "--z3rlimit 32 --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Apply a total transformation on parsed data *)
let parse_strengthen_prf
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
: Tot Type
= (xbytes: bytes) ->
(consumed: consumed_length xbytes) ->
(x: t1) ->
Lemma
(requires (parse p1 xbytes == Some (x, consumed)))
(ensures (p2 x))
let bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1 { p2 x } ))
= fun (xbytes: bytes) ->
match parse p1 xbytes with
| Some (x, consumed) ->
prf xbytes consumed x;
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
let bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf))
= let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . no_lookahead_on p1 b1 b2 ==> no_lookahead_on p' b1 b2)
let bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . injective_precond p' b1 b2 ==> injective_precond p1 b1 b2);
assert (forall (b1 b2: bytes) . injective_postcond p1 b1 b2 ==> injective_postcond p' b1 b2)
let bare_parse_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf) /\ | false | false | LowParse.Spec.Combinators.fsti | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bare_parse_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: (t1 -> GTot Type0))
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf) /\
parser_kind_prop k (bare_parse_strengthen p1 p2 prf)) | [] | LowParse.Spec.Combinators.bare_parse_strengthen_correct | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p1: LowParse.Spec.Base.parser k t1 ->
p2: (_: t1 -> Prims.GTot Type0) ->
prf: LowParse.Spec.Combinators.parse_strengthen_prf p1 p2
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Base.injective (LowParse.Spec.Combinators.bare_parse_strengthen p1 p2 prf) /\
LowParse.Spec.Base.parser_kind_prop k
(LowParse.Spec.Combinators.bare_parse_strengthen p1 p2 prf)) | {
"end_col": 4,
"end_line": 1671,
"start_col": 2,
"start_line": 1667
} |
FStar.Pervasives.Lemma | val tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (tot_parser k (refine_with_tag tag_of_data t))))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input ==
(match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input | val tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (tot_parser k (refine_with_tag tag_of_data t))))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input ==
(match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (tot_parser k (refine_with_tag tag_of_data t))))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input ==
(match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None)) = | false | null | true | parse_tagged_union_eq #kt pt tag_of_data #k p input | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.tot_parser",
"LowParse.Spec.Base.refine_with_tag",
"LowParse.Bytes.bytes",
"LowParse.Spec.Combinators.parse_tagged_union_eq",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Combinators.tot_parse_tagged_union",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"Prims.op_Addition",
"FStar.Seq.Base.seq",
"LowParse.Bytes.byte",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.length",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end | false | false | LowParse.Spec.Combinators.fsti | {
"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"
} | null | val tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (tot_parser k (refine_with_tag tag_of_data t))))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input ==
(match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None)) | [] | LowParse.Spec.Combinators.tot_parse_tagged_union_eq | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
pt: LowParse.Spec.Base.tot_parser kt tag_t ->
tag_of_data: (_: data_t -> tag_t) ->
p:
(t: tag_t
-> LowParse.Spec.Base.tot_parser k (LowParse.Spec.Base.refine_with_tag tag_of_data t)) ->
input: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Base.parse (LowParse.Spec.Combinators.tot_parse_tagged_union pt tag_of_data p)
input ==
(match LowParse.Spec.Base.parse pt input with
| FStar.Pervasives.Native.None #_ -> FStar.Pervasives.Native.None
| FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ tg consumed_tg) ->
let input_tg = FStar.Seq.Base.slice input consumed_tg (FStar.Seq.Base.length input) in
(match LowParse.Spec.Base.parse (p tg) input_tg with
| FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ x consumed_x) ->
FStar.Pervasives.Native.Some (x, consumed_tg + consumed_x)
| FStar.Pervasives.Native.None #_ -> FStar.Pervasives.Native.None)
<:
FStar.Pervasives.Native.option (data_t * LowParse.Spec.Base.consumed_length input))) | {
"end_col": 53,
"end_line": 1050,
"start_col": 2,
"start_line": 1050
} |
FStar.Pervasives.Lemma | val tot_parse_filter_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(f: (t -> Tot bool))
(input: bytes)
: Lemma
(parse (tot_parse_filter p f) input ==
(match parse p input with
| None -> None
| Some (x, consumed) -> if f x then Some (x, consumed) else None)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let tot_parse_filter_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(f: (t -> Tot bool))
(input: bytes)
: Lemma
(parse (tot_parse_filter p f) input == (match parse p input with
| None -> None
| Some (x, consumed) ->
if f x
then Some (x, consumed)
else None
))
= parse_filter_eq #k p f input | val tot_parse_filter_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(f: (t -> Tot bool))
(input: bytes)
: Lemma
(parse (tot_parse_filter p f) input ==
(match parse p input with
| None -> None
| Some (x, consumed) -> if f x then Some (x, consumed) else None))
let tot_parse_filter_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(f: (t -> Tot bool))
(input: bytes)
: Lemma
(parse (tot_parse_filter p f) input ==
(match parse p input with
| None -> None
| Some (x, consumed) -> if f x then Some (x, consumed) else None)) = | false | null | true | parse_filter_eq #k p f input | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.tot_parser",
"Prims.bool",
"LowParse.Bytes.bytes",
"LowParse.Spec.Combinators.parse_filter_eq",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Combinators.tot_parse_filter",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2)
val serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
: Tot (serializer (nondep_then p1 p2))
val serialize_nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input: t1 * t2)
: Lemma
(serialize (serialize_nondep_then s1 s2) input == bare_serialize_nondep_then p1 s1 p2 s2 input)
val length_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input1: t1)
(input2: t2)
: Lemma
(Seq.length (serialize (serialize_nondep_then s1 s2) (input1, input2)) == Seq.length (serialize s1 input1) + Seq.length (serialize s2 input2))
val serialize_nondep_then_upd_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s 0 (serialize s1 y)
))
val serialize_nondep_then_upd_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s i' s'
))
val serialize_nondep_then_upd_bw_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s len2 (serialize s1 y)
))
#reset-options "--z3refresh --z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val serialize_nondep_then_upd_bw_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_bw_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s (len2 + i') s'
))
val serialize_nondep_then_upd_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (Seq.length s - Seq.length (serialize s2 y)) (serialize s2 y)
))
val serialize_nondep_then_upd_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
l1 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (l1 + i') s'
))
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y)
))
= serialize_nondep_then_upd_right s1 s2 x y
let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_bw_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s'
))
= let s2' = serialize s2 (snd x) in
let j' = Seq.length s2' - i' - Seq.length s' in
assert (j' + Seq.length s' <= Seq.length s2');
assert (serialize s2 y == seq_upd_seq s2' j' s');
let s = serialize (serialize_nondep_then s1 s2) x in
serialize_nondep_then_upd_right_chain s1 s2 x y j' s';
assert (Seq.length (serialize s1 (fst x)) + j' == Seq.length s - i' - Seq.length s');
()
#reset-options "--z3rlimit 32 --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Apply a total transformation on parsed data *)
let parse_strengthen_prf
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
: Tot Type
= (xbytes: bytes) ->
(consumed: consumed_length xbytes) ->
(x: t1) ->
Lemma
(requires (parse p1 xbytes == Some (x, consumed)))
(ensures (p2 x))
let bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1 { p2 x } ))
= fun (xbytes: bytes) ->
match parse p1 xbytes with
| Some (x, consumed) ->
prf xbytes consumed x;
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
let bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf))
= let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . no_lookahead_on p1 b1 b2 ==> no_lookahead_on p' b1 b2)
let bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . injective_precond p' b1 b2 ==> injective_precond p1 b1 b2);
assert (forall (b1 b2: bytes) . injective_postcond p1 b1 b2 ==> injective_postcond p' b1 b2)
let bare_parse_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf) /\
parser_kind_prop k (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
bare_parse_strengthen_no_lookahead p1 p2 prf;
bare_parse_strengthen_injective p1 p2 prf;
parser_kind_prop_equiv k (bare_parse_strengthen p1 p2 prf);
()
let parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser k (x: t1 { p2 x } ))
= bare_parse_strengthen_correct p1 p2 prf;
bare_parse_strengthen p1 p2 prf
let serialize_strengthen'
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: GTot bytes
= serialize s input
let serialize_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: Lemma
(let output = serialize_strengthen' p2 prf s input in
parse (parse_strengthen p1 p2 prf) output == Some (input, Seq.length output))
= ()
let serialize_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
: Tot (serializer (parse_strengthen p1 p2 prf))
= Classical.forall_intro (serialize_strengthen_correct p2 prf s);
serialize_strengthen' p2 prf s
let compose (#t1 #t2 #t3: Type) (f1: t1 -> GTot t2) (f2: t2 -> GTot t3) (x: t1) : GTot t3 =
let y1 = f1 x in
f2 y1
val make_total_constant_size_parser_compose
(sz: nat)
(t1 t2: Type)
(f1: ((s: bytes {Seq.length s == sz}) -> GTot t1))
(g2: t1 -> GTot t2)
: Lemma
(requires (
make_total_constant_size_parser_precond sz t1 f1 /\
(forall x x' . g2 x == g2 x' ==> x == x')
))
(ensures (
make_total_constant_size_parser_precond sz t1 f1 /\
make_total_constant_size_parser_precond sz t2 (f1 `compose` g2) /\
(forall x x' . {:pattern (g2 x); (g2 x')} g2 x == g2 x' ==> x == x') /\
(forall input . {:pattern (parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input)} parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input == parse (make_total_constant_size_parser sz t1 f1 `parse_synth` g2) input)
))
(** Tot vs. Ghost *)
unfold
let lift_parser'
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (bare_parser t)
= fun (input: bytes) -> parse (f ()) input
let lift_parser_correct
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Lemma
(parser_kind_prop k (lift_parser' f))
= parser_kind_prop_ext k (f ()) (lift_parser' f)
let lift_parser
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (parser k t)
= lift_parser_correct f;
lift_parser' f
unfold
let lift_serializer'
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Tot (bare_serializer t)
= fun (x: t) -> serialize (s ()) x
let lift_serializer_correct
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Lemma
(serializer_correct (lift_parser f) (lift_serializer' s))
= ()
let lift_serializer
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Tot (serializer #k #t (lift_parser f))
= lift_serializer_correct #k #t #f s;
lift_serializer' #k #t #f s
(** Refinements *)
// unfold
inline_for_extraction
let parse_filter_kind (k: parser_kind) : Tot parser_kind =
{
parser_kind_low = k.parser_kind_low;
parser_kind_high = k.parser_kind_high;
parser_kind_metadata =
begin match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
end;
parser_kind_subkind = k.parser_kind_subkind;
}
// unfold
let parse_filter_payload_kind : parser_kind =
strong_parser_kind 0 0 None
let parse_filter_refine (#t: Type) (f: (t -> GTot bool)) =
(x: t { f x == true } )
let parse_filter_payload
(#t: Type)
(f: (t -> GTot bool))
(v: t)
: Tot (parser parse_filter_payload_kind (parse_filter_refine f))
= let p = lift_parser (fun () ->
if f v
then
let v' : (x: t { f x == true } ) = v in
weaken parse_filter_payload_kind (parse_ret v')
else fail_parser parse_filter_payload_kind (parse_filter_refine f)
)
in
parser_kind_prop_equiv parse_filter_payload_kind p;
p
val parse_filter
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
: Tot (parser (parse_filter_kind k) (parse_filter_refine f))
val parse_filter_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: bytes)
: Lemma
(parse (parse_filter p f) input == (match parse p input with
| None -> None
| Some (x, consumed) ->
if f x
then Some (x, consumed)
else None
))
val tot_parse_filter
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(f: (t -> Tot bool))
: Pure (tot_parser (parse_filter_kind k) (parse_filter_refine f))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_filter #k p f) x
))
let tot_parse_filter_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(f: (t -> Tot bool))
(input: bytes)
: Lemma
(parse (tot_parse_filter p f) input == (match parse p input with
| None -> None
| Some (x, consumed) ->
if f x
then Some (x, consumed)
else None | false | false | LowParse.Spec.Combinators.fsti | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tot_parse_filter_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(f: (t -> Tot bool))
(input: bytes)
: Lemma
(parse (tot_parse_filter p f) input ==
(match parse p input with
| None -> None
| Some (x, consumed) -> if f x then Some (x, consumed) else None)) | [] | LowParse.Spec.Combinators.tot_parse_filter_eq | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: LowParse.Spec.Base.tot_parser k t -> f: (_: t -> Prims.bool) -> input: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Base.parse (LowParse.Spec.Combinators.tot_parse_filter p f) input ==
(match LowParse.Spec.Base.parse p input with
| FStar.Pervasives.Native.None #_ -> FStar.Pervasives.Native.None
| FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ x consumed) ->
(match f x with
| true -> FStar.Pervasives.Native.Some (x, consumed)
| _ -> FStar.Pervasives.Native.None)
<:
FStar.Pervasives.Native.option (LowParse.Spec.Combinators.parse_filter_refine f *
LowParse.Spec.Base.consumed_length input))) | {
"end_col": 30,
"end_line": 1878,
"start_col": 2,
"start_line": 1878
} |
Prims.Tot | val serialize_tot_weaken
(#k: parser_kind)
(#t: Type)
(k': parser_kind)
(#p: tot_parser k t)
(s: serializer #k p {k' `is_weaker_than` k})
: Tot (serializer #k' (tot_weaken k' p)) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let serialize_tot_weaken
(#k: parser_kind)
(#t: Type)
(k' : parser_kind)
(#p: tot_parser k t)
(s: serializer #k p { k' `is_weaker_than` k })
: Tot (serializer #k' (tot_weaken k' p))
= serialize_ext #k _ s #k' (tot_weaken k' p) | val serialize_tot_weaken
(#k: parser_kind)
(#t: Type)
(k': parser_kind)
(#p: tot_parser k t)
(s: serializer #k p {k' `is_weaker_than` k})
: Tot (serializer #k' (tot_weaken k' p))
let serialize_tot_weaken
(#k: parser_kind)
(#t: Type)
(k': parser_kind)
(#p: tot_parser k t)
(s: serializer #k p {k' `is_weaker_than` k})
: Tot (serializer #k' (tot_weaken k' p)) = | false | null | false | serialize_ext #k _ s #k' (tot_weaken k' p) | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.tot_parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.Base.is_weaker_than",
"LowParse.Spec.Base.serialize_ext",
"LowParse.Spec.Base.tot_weaken"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2)
val serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
: Tot (serializer (nondep_then p1 p2))
val serialize_nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input: t1 * t2)
: Lemma
(serialize (serialize_nondep_then s1 s2) input == bare_serialize_nondep_then p1 s1 p2 s2 input)
val length_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input1: t1)
(input2: t2)
: Lemma
(Seq.length (serialize (serialize_nondep_then s1 s2) (input1, input2)) == Seq.length (serialize s1 input1) + Seq.length (serialize s2 input2))
val serialize_nondep_then_upd_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s 0 (serialize s1 y)
))
val serialize_nondep_then_upd_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s i' s'
))
val serialize_nondep_then_upd_bw_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s len2 (serialize s1 y)
))
#reset-options "--z3refresh --z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val serialize_nondep_then_upd_bw_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_bw_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s (len2 + i') s'
))
val serialize_nondep_then_upd_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (Seq.length s - Seq.length (serialize s2 y)) (serialize s2 y)
))
val serialize_nondep_then_upd_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
l1 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (l1 + i') s'
))
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y)
))
= serialize_nondep_then_upd_right s1 s2 x y
let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_bw_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s'
))
= let s2' = serialize s2 (snd x) in
let j' = Seq.length s2' - i' - Seq.length s' in
assert (j' + Seq.length s' <= Seq.length s2');
assert (serialize s2 y == seq_upd_seq s2' j' s');
let s = serialize (serialize_nondep_then s1 s2) x in
serialize_nondep_then_upd_right_chain s1 s2 x y j' s';
assert (Seq.length (serialize s1 (fst x)) + j' == Seq.length s - i' - Seq.length s');
()
#reset-options "--z3rlimit 32 --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Apply a total transformation on parsed data *)
let parse_strengthen_prf
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
: Tot Type
= (xbytes: bytes) ->
(consumed: consumed_length xbytes) ->
(x: t1) ->
Lemma
(requires (parse p1 xbytes == Some (x, consumed)))
(ensures (p2 x))
let bare_parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (bare_parser (x: t1 { p2 x } ))
= fun (xbytes: bytes) ->
match parse p1 xbytes with
| Some (x, consumed) ->
prf xbytes consumed x;
let (x' : t1 { p2 x' } ) = x in
Some (x', consumed)
| _ -> None
let bare_parse_strengthen_no_lookahead
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(no_lookahead p1 ==> no_lookahead (bare_parse_strengthen p1 p2 prf))
= let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . no_lookahead_on p1 b1 b2 ==> no_lookahead_on p' b1 b2)
let bare_parse_strengthen_injective
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
let p' : bare_parser (x: t1 { p2 x } ) = bare_parse_strengthen p1 p2 prf in
assert (forall (b1 b2: bytes) . injective_precond p' b1 b2 ==> injective_precond p1 b1 b2);
assert (forall (b1 b2: bytes) . injective_postcond p1 b1 b2 ==> injective_postcond p' b1 b2)
let bare_parse_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Lemma
(injective (bare_parse_strengthen p1 p2 prf) /\
parser_kind_prop k (bare_parse_strengthen p1 p2 prf))
= parser_kind_prop_equiv k p1;
bare_parse_strengthen_no_lookahead p1 p2 prf;
bare_parse_strengthen_injective p1 p2 prf;
parser_kind_prop_equiv k (bare_parse_strengthen p1 p2 prf);
()
let parse_strengthen
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
: Tot (parser k (x: t1 { p2 x } ))
= bare_parse_strengthen_correct p1 p2 prf;
bare_parse_strengthen p1 p2 prf
let serialize_strengthen'
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: GTot bytes
= serialize s input
let serialize_strengthen_correct
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
(input: t1 { p2 input } )
: Lemma
(let output = serialize_strengthen' p2 prf s input in
parse (parse_strengthen p1 p2 prf) output == Some (input, Seq.length output))
= ()
let serialize_strengthen
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(p2: t1 -> GTot Type0)
(prf: parse_strengthen_prf p1 p2)
(s: serializer p1)
: Tot (serializer (parse_strengthen p1 p2 prf))
= Classical.forall_intro (serialize_strengthen_correct p2 prf s);
serialize_strengthen' p2 prf s
let compose (#t1 #t2 #t3: Type) (f1: t1 -> GTot t2) (f2: t2 -> GTot t3) (x: t1) : GTot t3 =
let y1 = f1 x in
f2 y1
val make_total_constant_size_parser_compose
(sz: nat)
(t1 t2: Type)
(f1: ((s: bytes {Seq.length s == sz}) -> GTot t1))
(g2: t1 -> GTot t2)
: Lemma
(requires (
make_total_constant_size_parser_precond sz t1 f1 /\
(forall x x' . g2 x == g2 x' ==> x == x')
))
(ensures (
make_total_constant_size_parser_precond sz t1 f1 /\
make_total_constant_size_parser_precond sz t2 (f1 `compose` g2) /\
(forall x x' . {:pattern (g2 x); (g2 x')} g2 x == g2 x' ==> x == x') /\
(forall input . {:pattern (parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input)} parse (make_total_constant_size_parser sz t2 (f1 `compose` g2)) input == parse (make_total_constant_size_parser sz t1 f1 `parse_synth` g2) input)
))
(** Tot vs. Ghost *)
unfold
let lift_parser'
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (bare_parser t)
= fun (input: bytes) -> parse (f ()) input
let lift_parser_correct
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Lemma
(parser_kind_prop k (lift_parser' f))
= parser_kind_prop_ext k (f ()) (lift_parser' f)
let lift_parser
(#k: parser_kind)
(#t: Type)
(f: unit -> GTot (parser k t))
: Tot (parser k t)
= lift_parser_correct f;
lift_parser' f
unfold
let lift_serializer'
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Tot (bare_serializer t)
= fun (x: t) -> serialize (s ()) x
let lift_serializer_correct
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Lemma
(serializer_correct (lift_parser f) (lift_serializer' s))
= ()
let lift_serializer
(#k: parser_kind)
(#t: Type)
(#f: unit -> GTot (parser k t))
(s: unit -> GTot (serializer (f ())))
: Tot (serializer #k #t (lift_parser f))
= lift_serializer_correct #k #t #f s;
lift_serializer' #k #t #f s
(** Refinements *)
// unfold
inline_for_extraction
let parse_filter_kind (k: parser_kind) : Tot parser_kind =
{
parser_kind_low = k.parser_kind_low;
parser_kind_high = k.parser_kind_high;
parser_kind_metadata =
begin match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
end;
parser_kind_subkind = k.parser_kind_subkind;
}
// unfold
let parse_filter_payload_kind : parser_kind =
strong_parser_kind 0 0 None
let parse_filter_refine (#t: Type) (f: (t -> GTot bool)) =
(x: t { f x == true } )
let parse_filter_payload
(#t: Type)
(f: (t -> GTot bool))
(v: t)
: Tot (parser parse_filter_payload_kind (parse_filter_refine f))
= let p = lift_parser (fun () ->
if f v
then
let v' : (x: t { f x == true } ) = v in
weaken parse_filter_payload_kind (parse_ret v')
else fail_parser parse_filter_payload_kind (parse_filter_refine f)
)
in
parser_kind_prop_equiv parse_filter_payload_kind p;
p
val parse_filter
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
: Tot (parser (parse_filter_kind k) (parse_filter_refine f))
val parse_filter_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: bytes)
: Lemma
(parse (parse_filter p f) input == (match parse p input with
| None -> None
| Some (x, consumed) ->
if f x
then Some (x, consumed)
else None
))
val tot_parse_filter
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(f: (t -> Tot bool))
: Pure (tot_parser (parse_filter_kind k) (parse_filter_refine f))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_filter #k p f) x
))
let tot_parse_filter_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(f: (t -> Tot bool))
(input: bytes)
: Lemma
(parse (tot_parse_filter p f) input == (match parse p input with
| None -> None
| Some (x, consumed) ->
if f x
then Some (x, consumed)
else None
))
= parse_filter_eq #k p f input
let serialize_filter'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(f: (t -> GTot bool))
: Tot (bare_serializer (x: t { f x == true } ))
= fun (input: t { f input == true } ) -> s input
val serialize_filter_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(f: (t -> GTot bool))
: Lemma
(serializer_correct (parse_filter p f) (serialize_filter' s f))
let serialize_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(f: (t -> GTot bool))
: Tot (serializer (parse_filter p f))
= serialize_filter_correct s f;
serialize_filter' s f
let serialize_tot_filter
(#k: parser_kind)
(#t: Type)
(#p: tot_parser k t)
(s: serializer #k p)
(f: (t -> Tot bool))
: Tot (serializer (tot_parse_filter p f))
= serialize_ext #(parse_filter_kind k) _ (serialize_filter s f) #(parse_filter_kind k) _
let serialize_weaken
(#k: parser_kind)
(#t: Type)
(k' : parser_kind)
(#p: parser k t)
(s: serializer p { k' `is_weaker_than` k })
: Tot (serializer (weaken k' p))
= serialize_ext _ s (weaken k' p)
let serialize_tot_weaken
(#k: parser_kind)
(#t: Type)
(k' : parser_kind)
(#p: tot_parser k t)
(s: serializer #k p { k' `is_weaker_than` k }) | false | false | LowParse.Spec.Combinators.fsti | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_tot_weaken
(#k: parser_kind)
(#t: Type)
(k': parser_kind)
(#p: tot_parser k t)
(s: serializer #k p {k' `is_weaker_than` k})
: Tot (serializer #k' (tot_weaken k' p)) | [] | LowParse.Spec.Combinators.serialize_tot_weaken | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
k': LowParse.Spec.Base.parser_kind ->
s: LowParse.Spec.Base.serializer p {LowParse.Spec.Base.is_weaker_than k' k}
-> LowParse.Spec.Base.serializer (LowParse.Spec.Base.tot_weaken k' p) | {
"end_col": 44,
"end_line": 1933,
"start_col": 2,
"start_line": 1933
} |
FStar.Pervasives.Lemma | val serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: (t1 * t2))
(y: t2)
: Lemma (requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures
(let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y))
) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y)
))
= serialize_nondep_then_upd_right s1 s2 x y | val serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: (t1 * t2))
(y: t2)
: Lemma (requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures
(let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y))
)
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma (requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures
(let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y))
) = | false | null | true | serialize_nondep_then_upd_right s1 s2 x y | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Combinators.serialize_nondep_then_upd_right",
"Prims.unit",
"Prims.nat",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.serialize",
"FStar.Pervasives.Native.snd",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.seq",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.nondep_then",
"LowParse.Spec.Combinators.serialize_nondep_then",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.fst",
"LowParse.Spec.Base.seq_upd_bw_seq",
"LowParse.Bytes.bytes",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2)
val serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
: Tot (serializer (nondep_then p1 p2))
val serialize_nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input: t1 * t2)
: Lemma
(serialize (serialize_nondep_then s1 s2) input == bare_serialize_nondep_then p1 s1 p2 s2 input)
val length_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input1: t1)
(input2: t2)
: Lemma
(Seq.length (serialize (serialize_nondep_then s1 s2) (input1, input2)) == Seq.length (serialize s1 input1) + Seq.length (serialize s2 input2))
val serialize_nondep_then_upd_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s 0 (serialize s1 y)
))
val serialize_nondep_then_upd_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s i' s'
))
val serialize_nondep_then_upd_bw_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s len2 (serialize s1 y)
))
#reset-options "--z3refresh --z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val serialize_nondep_then_upd_bw_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_bw_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s (len2 + i') s'
))
val serialize_nondep_then_upd_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (Seq.length s - Seq.length (serialize s2 y)) (serialize s2 y)
))
val serialize_nondep_then_upd_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
l1 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (l1 + i') s'
))
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y) | false | false | LowParse.Spec.Combinators.fsti | {
"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": 64,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: (t1 * t2))
(y: t2)
: Lemma (requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures
(let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y))
) | [] | LowParse.Spec.Combinators.serialize_nondep_then_upd_bw_right | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s1:
LowParse.Spec.Base.serializer p1
{ Mkparser_kind'?.parser_kind_subkind k1 ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } ->
s2: LowParse.Spec.Base.serializer p2 ->
x: (t1 * t2) ->
y: t2
-> FStar.Pervasives.Lemma
(requires
FStar.Seq.Base.length (LowParse.Spec.Base.serialize s2 y) ==
FStar.Seq.Base.length (LowParse.Spec.Base.serialize s2 (FStar.Pervasives.Native.snd x)))
(ensures
(let s =
LowParse.Spec.Base.serialize (LowParse.Spec.Combinators.serialize_nondep_then s1 s2) x
in
FStar.Seq.Base.length (LowParse.Spec.Base.serialize s2 y) <= FStar.Seq.Base.length s /\
LowParse.Spec.Base.serialize (LowParse.Spec.Combinators.serialize_nondep_then s1 s2)
(FStar.Pervasives.Native.fst x, y) ==
LowParse.Spec.Base.seq_upd_bw_seq s 0 (LowParse.Spec.Base.serialize s2 y))) | {
"end_col": 43,
"end_line": 1565,
"start_col": 2,
"start_line": 1565
} |
FStar.Pervasives.Lemma | val serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: (t1 * t2))
(y: t2)
(i': nat)
(s': bytes)
: Lemma
(requires
(let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\ serialize s2 y == seq_upd_bw_seq s2' i' s'))
(ensures
(let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s')) | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"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
}
] | false | let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_bw_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s'
))
= let s2' = serialize s2 (snd x) in
let j' = Seq.length s2' - i' - Seq.length s' in
assert (j' + Seq.length s' <= Seq.length s2');
assert (serialize s2 y == seq_upd_seq s2' j' s');
let s = serialize (serialize_nondep_then s1 s2) x in
serialize_nondep_then_upd_right_chain s1 s2 x y j' s';
assert (Seq.length (serialize s1 (fst x)) + j' == Seq.length s - i' - Seq.length s');
() | val serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: (t1 * t2))
(y: t2)
(i': nat)
(s': bytes)
: Lemma
(requires
(let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\ serialize s2 y == seq_upd_bw_seq s2' i' s'))
(ensures
(let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s'))
let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i': nat)
(s': bytes)
: Lemma
(requires
(let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\ serialize s2 y == seq_upd_bw_seq s2' i' s'))
(ensures
(let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s')) = | false | null | true | let s2' = serialize s2 (snd x) in
let j' = Seq.length s2' - i' - Seq.length s' in
assert (j' + Seq.length s' <= Seq.length s2');
assert (serialize s2 y == seq_upd_seq s2' j' s');
let s = serialize (serialize_nondep_then s1 s2) x in
serialize_nondep_then_upd_right_chain s1 s2 x y j' s';
assert (Seq.length (serialize s1 (fst x)) + j' == Seq.length s - i' - Seq.length s');
() | {
"checked_file": "LowParse.Spec.Combinators.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Combinators.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"LowParse.Bytes.bytes",
"Prims.unit",
"Prims._assert",
"Prims.int",
"Prims.op_Addition",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.serialize",
"FStar.Pervasives.Native.fst",
"Prims.op_Subtraction",
"LowParse.Spec.Combinators.serialize_nondep_then_upd_right_chain",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.nondep_then",
"LowParse.Spec.Combinators.serialize_nondep_then",
"FStar.Seq.Base.seq",
"LowParse.Spec.Base.seq_upd_seq",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Pervasives.Native.snd",
"Prims.l_and",
"LowParse.Spec.Base.seq_upd_bw_seq",
"Prims.squash",
"FStar.Pervasives.Native.Mktuple2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Combinators
include LowParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module T = FStar.Tactics
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (parse p b1));
assert (Some? (parse p b2));
let (Some (v1, len1)) = parse p b1 in
let (Some (v2, len2)) = parse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let constant_size_parser_kind
(sz: nat)
: Tot parser_kind
= strong_parser_kind sz sz None
let make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (
parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let tot_make_constant_size_parser_aux
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Tot (tot_bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let tot_make_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot (option t)))
: Pure (
tot_parser
(constant_size_parser_kind sz)
t
)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
parser_kind_prop_equiv (constant_size_parser_kind sz) p;
p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) . {:pattern (f s1); (f s2)}
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (
parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
let tot_make_total_constant_size_parser
(sz: nat)
(t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> Tot t))
: Pure (
tot_parser
(total_constant_size_parser_kind sz)
t
)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : tot_bare_parser t = tot_make_constant_size_parser sz t (fun x -> Some (f x)) in
parser_kind_prop_equiv (total_constant_size_parser_kind sz) p;
p
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (tot_bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
// unfold
inline_for_extraction
let parse_ret_kind : parser_kind =
strong_parser_kind 0 0 (Some ParserKindMetadataTotal)
let tot_parse_ret (#t:Type) (v:t) : Tot (tot_parser parse_ret_kind t) =
parser_kind_prop_equiv parse_ret_kind (parse_ret' v);
parse_ret' v
let parse_ret (#t:Type) (v:t) : Tot (parser parse_ret_kind t) =
tot_parse_ret v
let serialize_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer (parse_ret v))
= mk_serializer
(parse_ret v)
(fun (x: t) -> Seq.empty)
(fun x -> v_unique x)
let parse_empty : parser parse_ret_kind unit =
parse_ret ()
let serialize_empty : serializer parse_empty = serialize_ret () (fun _ -> ())
#set-options "--z3rlimit 16"
let fail_parser_kind_precond
(k: parser_kind)
: GTot Type0
= k.parser_kind_metadata <> Some ParserKindMetadataTotal /\
(Some? k.parser_kind_high ==> k.parser_kind_low <= Some?.v k.parser_kind_high)
let fail_parser'
(t: Type)
: Tot (tot_bare_parser t)
= fun _ -> None
let tot_fail_parser
(k: parser_kind)
(t: Type)
: Pure (tot_parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= let p = fail_parser' t in
parser_kind_prop_equiv k p;
tot_strengthen k p
let fail_parser
(k: parser_kind)
(t: Type)
: Pure (parser k t)
(requires (fail_parser_kind_precond k))
(ensures (fun _ -> True))
= tot_fail_parser k t
let fail_serializer
(k: parser_kind {fail_parser_kind_precond k} )
(t: Type)
(prf: (x: t) -> Lemma False)
: Tot (serializer (fail_parser k t))
= mk_serializer
(fail_parser k t)
(fun x -> prf x; false_elim ())
(fun x -> prf x)
inline_for_extraction
let parse_false_kind = strong_parser_kind 0 0 (Some ParserKindMetadataFail)
let parse_false : parser parse_false_kind (squash False) = fail_parser _ _
let serialize_false : serializer parse_false = fun input -> false_elim ()
/// monadic bind for the parser monad
let and_then_bare (#t:Type) (#t':Type)
(p:bare_parser t)
(p': (t -> Tot (bare_parser t'))) :
Tot (bare_parser t') =
fun (b: bytes) ->
match parse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match parse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? (parse (p' x1) b1) /\
Some? (parse (p' x2) b2) /\ (
let (Some (v1, _)) = parse (p' x1) b1 in
let (Some (v2, _)) = parse (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) . {:pattern (parse (p' x1) b1); (parse (p' x2) b2)}
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let and_then_cases_injective_intro
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(lem: (
(x1: t) ->
(x2: t) ->
(b1: bytes) ->
(b2: bytes) ->
Lemma
(requires (and_then_cases_injective_precond p' x1 x2 b1 b2))
(ensures (x1 == x2))
))
: Lemma
(and_then_cases_injective p')
= Classical.forall_intro_3 (fun x1 x2 b1 -> Classical.forall_intro (Classical.move_requires (lem x1 x2 b1)))
let and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p')
))
= let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
let and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
=
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
inline_for_extraction
let and_then_metadata
(k1 k2: parser_kind_metadata_t)
: Tot parser_kind_metadata_t
= match k1, k2 with
| Some ParserKindMetadataFail, _ -> k1
| _, Some ParserKindMetadataFail -> k2
| Some ParserKindMetadataTotal, Some ParserKindMetadataTotal -> k1
| _ -> None
// unfold
inline_for_extraction
let and_then_kind
(k1 k2: parser_kind)
: Tot parser_kind
= {
parser_kind_low = k1.parser_kind_low + k2.parser_kind_low;
parser_kind_high =
begin
if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high
then Some (some_v k1.parser_kind_high + some_v k2.parser_kind_high)
else None
end;
parser_kind_metadata = and_then_metadata k1.parser_kind_metadata k2.parser_kind_metadata;
parser_kind_subkind =
begin
if k2.parser_kind_subkind = Some ParserConsumesAll
then Some ParserConsumesAll
else if (k1.parser_kind_subkind = Some ParserStrong) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then Some ParserStrong
else if (k2.parser_kind_high = Some 0) `bool_and` (k2.parser_kind_subkind = Some ParserStrong)
then k1.parser_kind_subkind
else None
end;
}
let and_then_no_lookahead
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures ((k.parser_kind_subkind == Some ParserStrong /\ k'.parser_kind_subkind == Some ParserStrong) ==> no_lookahead (and_then_bare p p')))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun (x: t) -> parser_kind_prop_equiv k' (p' x));
if k.parser_kind_subkind = Some ParserStrong && k.parser_kind_subkind = Some ParserStrong then
Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on p p' x))
else ()
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
injective (and_then_bare p p') /\
parser_kind_prop (and_then_kind k k') (and_then_bare p p')
))
= parser_kind_prop_equiv k p;
Classical.forall_intro (fun x -> parser_kind_prop_equiv k' (p' x));
parser_kind_prop_equiv (and_then_kind k k') (and_then_bare p p');
and_then_injective p p';
and_then_no_lookahead p p'
#reset-options "--using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val and_then
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
: Pure (parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
val and_then_eq
(#k: parser_kind)
(#t:Type)
(p:parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (parser k' t')))
(input: bytes)
: Lemma
(requires (and_then_cases_injective p'))
(ensures (parse (and_then p p') input == and_then_bare p p' input))
val tot_and_then
(#k: parser_kind)
(#t:Type)
(p:tot_parser k t)
(#k': parser_kind)
(#t':Type)
(p': (t -> Tot (tot_parser k' t')))
: Pure (tot_parser (and_then_kind k k') t')
(requires (
and_then_cases_injective p'
))
(ensures (fun y ->
forall x . parse y x == parse (and_then #k p #k' p') x
))
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser parse_ret_kind t') =
[@inline_let] let _ = parser_kind_prop_equiv parse_ret_kind (parse_fret' f v) in
parse_fret' f v
let synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: GTot Type0
= forall (x x' : t1) . {:pattern (f x); (f x')} f x == f x' ==> x == x'
let synth_injective_intro
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
: Lemma
(requires (forall (x x' : t1) . f x == f x' ==> x == x'))
(ensures (synth_injective f))
= ()
let synth_injective_intro'
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(prf: (
(x: t1) ->
(x' : t1) ->
Lemma
(requires (f x == f x'))
(ensures (x == x'))
))
: Lemma
(synth_injective f)
= Classical.forall_intro_2 (fun x -> Classical.move_requires (prf x))
let parse_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Tot (bare_parser t2)
= fun b -> match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed)
val parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
: Pure (parser k t2)
(requires (
synth_injective f2
))
(ensures (fun _ -> True))
val parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
let parse_synth_eq2
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(sq: squash (synth_injective f2))
(b: bytes)
: Lemma
(ensures (parse (parse_synth p1 f2) b == parse_synth' p1 f2 b))
= parse_synth_eq p1 f2 b
val tot_parse_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
: Pure (tot_parser k t2)
(requires (
synth_injective f2
))
(ensures (fun y ->
forall x . parse y x == parse (parse_synth #k p1 f2) x
))
let tot_parse_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(b: bytes)
: Lemma
(requires (synth_injective f2))
(ensures (parse (tot_parse_synth p1 f2) b == parse_synth' #k p1 f2 b))
= parse_synth_eq #k p1 f2 b
let bare_serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) =
fun (x: t2) -> s1 (g1 x)
val bare_serialize_synth_correct
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
(forall (x : t2) . f2 (g1 x) == x) /\
(forall (x x' : t1) . f2 x == f2 x' ==> x == x')
))
(ensures (serializer_correct (parse_synth p1 f2) (bare_serialize_synth p1 f2 s1 g1 )))
let synth_inverse
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . {:pattern (f2 (g1 x))} f2 (g1 x) == x)
let synth_inverse_intro
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let synth_inverse_intro'
(#t1: Type)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(prf: (x: t2) -> Lemma (f2 (g1 x) == x))
: Lemma
(ensures (synth_inverse f2 g1))
= Classical.forall_intro prf
let synth_inverse_synth_injective_pat
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
[SMTPat (synth_inverse g f)]
= assert (forall x1 x2. f x1 == f x2 ==> g (f x1) == g (f x2))
let synth_inverse_synth_injective
(#t1: Type)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
: Lemma
(requires (synth_inverse g f))
(ensures (synth_injective f))
= ()
let synth_inverse_synth_injective'
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f))
: Tot (squash (synth_injective f))
= ()
let synth_injective_synth_inverse_synth_inverse_recip
(#t1: Type)
(#t2: Type)
(g: (t2 -> GTot t1))
(f: (t1 -> GTot t2))
(u: squash (synth_inverse g f /\ synth_injective g))
: Tot (squash (synth_inverse f g))
= assert (forall x . g (f (g x)) == g x)
val serialize_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer (parse_synth p1 f2))
val serialize_synth_eq
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
: Lemma
(serialize (serialize_synth p1 f2 s1 g1 u) x == serialize s1 (g1 x))
let serialize_synth_eq'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x: t2)
(y1: bytes)
(q1: squash (y1 == serialize (serialize_synth p1 f2 s1 g1 u) x))
(y2: bytes)
(q2: squash (y2 == serialize s1 (g1 x)))
: Lemma
(ensures (y1 == y2))
= serialize_synth_eq p1 f2 s1 g1 u x
let serialize_tot_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: tot_parser k t1)
(f2: t1 -> Tot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
: Tot (serializer #k (tot_parse_synth p1 f2))
= serialize_ext #k _ (serialize_synth #k p1 f2 s1 g1 u) _
val serialize_synth_upd_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_seq s i' s'
))
val serialize_synth_upd_bw_chain
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(s1: serializer p1)
(g1: t2 -> GTot t1)
(u: unit {
synth_inverse f2 g1 /\
synth_injective f2
})
(x1: t1)
(x2: t2)
(y1: t1)
(y2: t2)
(i': nat)
(s' : bytes)
: Lemma
(requires (
let s = serialize s1 x1 in
i' + Seq.length s' <= Seq.length s /\
serialize s1 y1 == seq_upd_bw_seq s i' s' /\
x2 == f2 x1 /\
y2 == f2 y1
))
(ensures (
let s = serialize (serialize_synth p1 f2 s1 g1 u) x2 in
i' + Seq.length s' <= Seq.length s /\
Seq.length s == Seq.length (serialize s1 x1) /\
serialize (serialize_synth p1 f2 s1 g1 u) y2 == seq_upd_bw_seq s i' s'
))
(* Strengthened versions of and_then *)
inline_for_extraction
let synth_tagged_union_data
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(tg: tag_t)
(x: refine_with_tag tag_of_data tg)
: Tot data_t
= x
let parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Tot (parser k data_t)
= parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
let parse_tagged_union_payload_and_then_cases_injective
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Lemma
(and_then_cases_injective (parse_tagged_union_payload tag_of_data p))
= and_then_cases_injective_intro (parse_tagged_union_payload tag_of_data p) (fun x1 x2 b1 b2 ->
parse_synth_eq #k #(refine_with_tag tag_of_data x1) (p x1) (synth_tagged_union_data tag_of_data x1) b1;
parse_synth_eq #k #(refine_with_tag tag_of_data x2) (p x2) (synth_tagged_union_data tag_of_data x2) b2
)
val parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (parser (and_then_kind kt k) data_t)
val parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
let bare_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(k': (t: tag_t) -> Tot parser_kind)
(p: (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(input: bytes)
: GTot (option (data_t * consumed_length input))
= match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
val parse_tagged_union_eq_gen
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(#kt': parser_kind)
(pt': parser kt' tag_t)
(lem_pt: (
(input: bytes) ->
Lemma
(parse pt input == parse pt' input)
))
(k': (t: tag_t) -> Tot parser_kind)
(p': (t: tag_t) -> Tot (parser (k' t) (refine_with_tag tag_of_data t)))
(lem_p' : (
(k: tag_t) ->
(input: bytes) ->
Lemma
(parse (p k) input == parse (p' k) input)
))
(input: bytes)
: Lemma
(parse (parse_tagged_union pt tag_of_data p) input == bare_parse_tagged_union pt' tag_of_data k' p' input)
let tot_parse_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(tg: tag_t)
: Pure (tot_parser k data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union_payload tag_of_data #k p tg) x
))
= tot_parse_synth #k #(refine_with_tag tag_of_data tg) (p tg) (synth_tagged_union_data tag_of_data tg)
val tot_parse_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
: Pure (tot_parser (and_then_kind kt k) data_t)
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_tagged_union #kt pt tag_of_data #k p) x
))
let tot_parse_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(pt: tot_parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(input: bytes)
: Lemma
(parse (tot_parse_tagged_union pt tag_of_data p) input == (match parse pt input with
| None -> None
| Some (tg, consumed_tg) ->
let input_tg = Seq.slice input consumed_tg (Seq.length input) in
begin match parse (p tg) input_tg with
| Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x)
| None -> None
end
))
= parse_tagged_union_eq #kt pt tag_of_data #k p input
let bare_serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Tot (bare_serializer data_t)
= fun (d: data_t) ->
let tg = tag_of_data d in
Seq.append (st tg) (serialize (s tg) d)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_tagged_union_correct
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serializer_correct (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s)))
= (* same proof as nondep_then *)
let prf
(x: data_t)
: Lemma (parse (parse_tagged_union pt tag_of_data p) (bare_serialize_tagged_union st tag_of_data s x) == Some (x, Seq.length (bare_serialize_tagged_union st tag_of_data s x)))
= parse_tagged_union_eq pt tag_of_data p (bare_serialize_tagged_union st tag_of_data s x);
let t = tag_of_data x in
let (u: refine_with_tag tag_of_data t) = x in
let v1' = parse pt (bare_serialize_tagged_union st tag_of_data s x) in
let v1 = parse pt (serialize st t) in
assert (Some? v1);
parser_kind_prop_equiv kt pt;
assert (no_lookahead_on pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (_, len')) = parse pt (serialize st t) in
assert (len' == Seq.length (serialize st t));
assert (len' <= Seq.length (bare_serialize_tagged_union st tag_of_data s x));
assert (Seq.slice (serialize st t) 0 len' == st t);
seq_slice_append_l (serialize st t) (serialize (s t) u);
assert (no_lookahead_on_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (no_lookahead_on_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (Some? v1');
assert (injective_precond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
assert (injective_postcond pt (serialize st t) (bare_serialize_tagged_union st tag_of_data s x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == t);
assert (len1 == Seq.length (serialize st t));
assert (bare_serialize_tagged_union st tag_of_data s x == Seq.append (serialize st t) (serialize (s t) u));
seq_slice_append_r (serialize st t) (serialize (s t) u);
()
in
Classical.forall_intro prf
val serialize_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
: Pure (serializer (parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
val serialize_tagged_union_eq
(#kt: parser_kind)
(#tag_t: Type)
(#pt: parser kt tag_t)
(st: serializer pt)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer (p t)))
(input: data_t)
: Lemma
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (serialize (serialize_tagged_union st tag_of_data s) input == bare_serialize_tagged_union st tag_of_data s input))
[SMTPat (serialize (serialize_tagged_union st tag_of_data s) input)]
let serialize_tot_tagged_union
(#kt: parser_kind)
(#tag_t: Type)
(#pt: tot_parser kt tag_t)
(st: serializer #kt pt)
(#data_t: Type)
(tag_of_data: (data_t -> Tot tag_t))
(#k: parser_kind)
(#p: (t: tag_t) -> Tot (tot_parser k (refine_with_tag tag_of_data t)))
(s: (t: tag_t) -> Tot (serializer #k (p t)))
: Pure (serializer #(and_then_kind kt k) (tot_parse_tagged_union pt tag_of_data p))
(requires (kt.parser_kind_subkind == Some ParserStrong))
(ensures (fun _ -> True))
= serialize_ext _
(serialize_tagged_union st tag_of_data s)
_
(* Dependent pairs *)
inline_for_extraction
let synth_dtuple2
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: t2 x)
: Tot (refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
= (| x, y |)
let parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (parser (and_then_kind k1 k2) (dtuple2 t1 t2))
= parse_tagged_union
p1
dfst
(fun (x: t1) -> parse_synth (p2 x) (synth_dtuple2 x))
inline_for_extraction
let synth_dtuple2_recip
(#t1: Type)
(#t2: t1 -> Type)
(x: t1)
(y: refine_with_tag #t1 #(dtuple2 t1 t2) dfst x)
: Tot (t2 x)
= dsnd y
val serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
: Tot (serializer (parse_dtuple2 p1 p2))
val parse_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
let bare_parse_dtuple2
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
: Tot (bare_parser (dtuple2 t1 t2))
= fun b ->
match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse (p2 x1) b' with
| Some (x2, consumed2) ->
Some ((| x1, x2 |), consumed1 + consumed2)
| _ -> None
end
| _ -> None
let parse_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(p2: (x: t1) -> parser k2 (t2 x))
(b: bytes)
: Lemma
(parse (parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2) b == bare_parse_dtuple2 #k1 #t1 p1 #k2 #t2 p2 b)
= parse_dtuple2_eq p1 p2 b
val serialize_dtuple2_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Lemma
(serialize (serialize_dtuple2 s1 s2) xy == serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy))
let bare_serialize_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: GTot bytes
= serialize s1 (dfst xy) `Seq.append` serialize (s2 (dfst xy)) (dsnd xy)
let serialize_dtuple2_eq'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1) -> parser k2 (t2 x))
(s2: (x: t1) -> serializer (p2 x))
(xy: dtuple2 t1 t2)
: Tot (squash (
(serialize #_ #(dtuple2 t1 t2) (serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2) xy == bare_serialize_dtuple2 #k1 #t1 #p1 s1 #k2 #t2 #p2 s2 xy)))
= serialize_dtuple2_eq s1 s2 xy
(* Special case for non-dependent parsing *)
val nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (parser (and_then_kind k1 k2) (t1 * t2))
#set-options "--z3rlimit 16"
val nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
val tot_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: tot_parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: tot_parser k2 t2)
: Pure (tot_parser (and_then_kind k1 k2) (t1 * t2))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (nondep_then #k1 p1 #k2 p2) x
))
let bare_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(s1: serializer p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s2: serializer p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (s1 x1) (s2 x2)
val serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
: Tot (serializer (nondep_then p1 p2))
val serialize_nondep_then_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input: t1 * t2)
: Lemma
(serialize (serialize_nondep_then s1 s2) input == bare_serialize_nondep_then p1 s1 p2 s2 input)
val length_serialize_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(input1: t1)
(input2: t2)
: Lemma
(Seq.length (serialize (serialize_nondep_then s1 s2) (input1, input2)) == Seq.length (serialize s1 input1) + Seq.length (serialize s2 input2))
val serialize_nondep_then_upd_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s 0 (serialize s1 y)
))
val serialize_nondep_then_upd_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_seq s i' s'
))
val serialize_nondep_then_upd_bw_left
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
: Lemma
(requires (Seq.length (serialize s1 y) == Seq.length (serialize s1 (fst x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + Seq.length (serialize s1 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s len2 (serialize s1 y)
))
#reset-options "--z3refresh --z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Tactis -FStar.Reflection'"
val serialize_nondep_then_upd_bw_left_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t1)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s1' = serialize s1 (fst x) in
i' + Seq.length s' <= Seq.length s1' /\
serialize s1 y == seq_upd_bw_seq s1' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let len2 = Seq.length (serialize s2 (snd x)) in
len2 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (y, snd x) == seq_upd_bw_seq s (len2 + i') s'
))
val serialize_nondep_then_upd_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (Seq.length s - Seq.length (serialize s2 y)) (serialize s2 y)
))
val serialize_nondep_then_upd_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
l1 + i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_seq s (l1 + i') s'
))
let serialize_nondep_then_upd_bw_right
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
: Lemma
(requires (Seq.length (serialize s2 y) == Seq.length (serialize s2 (snd x))))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
Seq.length (serialize s2 y) <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s 0 (serialize s2 y)
))
= serialize_nondep_then_upd_right s1 s2 x y
let serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: t1 * t2)
(y: t2)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\
serialize s2 y == seq_upd_bw_seq s2' i' s'
))
(ensures (
let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s' | false | false | LowParse.Spec.Combinators.fsti | {
"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": 64,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_nondep_then_upd_bw_right_chain
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(s1: serializer p1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2)
(x: (t1 * t2))
(y: t2)
(i': nat)
(s': bytes)
: Lemma
(requires
(let s2' = serialize s2 (snd x) in
i' + Seq.length s' <= Seq.length s2' /\ serialize s2 y == seq_upd_bw_seq s2' i' s'))
(ensures
(let s = serialize (serialize_nondep_then s1 s2) x in
let l1 = Seq.length (serialize s1 (fst x)) in
Seq.length s == l1 + Seq.length (serialize s2 (snd x)) /\
i' + Seq.length s' <= Seq.length s /\
serialize (serialize_nondep_then s1 s2) (fst x, y) == seq_upd_bw_seq s i' s')) | [] | LowParse.Spec.Combinators.serialize_nondep_then_upd_bw_right_chain | {
"file_name": "src/lowparse/LowParse.Spec.Combinators.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s1:
LowParse.Spec.Base.serializer p1
{ Mkparser_kind'?.parser_kind_subkind k1 ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } ->
s2: LowParse.Spec.Base.serializer p2 ->
x: (t1 * t2) ->
y: t2 ->
i': Prims.nat ->
s': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
(let s2' = LowParse.Spec.Base.serialize s2 (FStar.Pervasives.Native.snd x) in
i' + FStar.Seq.Base.length s' <= FStar.Seq.Base.length s2' /\
LowParse.Spec.Base.serialize s2 y == LowParse.Spec.Base.seq_upd_bw_seq s2' i' s'))
(ensures
(let s =
LowParse.Spec.Base.serialize (LowParse.Spec.Combinators.serialize_nondep_then s1 s2) x
in
let l1 =
FStar.Seq.Base.length (LowParse.Spec.Base.serialize s1 (FStar.Pervasives.Native.fst x))
in
FStar.Seq.Base.length s ==
l1 +
FStar.Seq.Base.length (LowParse.Spec.Base.serialize s2 (FStar.Pervasives.Native.snd x)) /\
i' + FStar.Seq.Base.length s' <= FStar.Seq.Base.length s /\
LowParse.Spec.Base.serialize (LowParse.Spec.Combinators.serialize_nondep_then s1 s2)
(FStar.Pervasives.Native.fst x, y) ==
LowParse.Spec.Base.seq_upd_bw_seq s i' s')) | {
"end_col": 4,
"end_line": 1600,
"start_col": 1,
"start_line": 1593
} |
Prims.Tot | val va_ens_Fadd
(va_b0: va_code)
(va_s0: va_state)
(dst_b inA_b inB_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))) | val va_ens_Fadd
(va_b0: va_code)
(va_s0: va_state)
(dst_b inA_b inB_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop
let va_ens_Fadd
(va_b0: va_code)
(va_s0: va_state)
(dst_b inA_b inB_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop = | false | null | false | (va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\
(let a0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let b0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let b1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let b2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let b3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let a:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let b:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in
let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in
let d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in
let d3 = Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in
let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in
d `op_Modulus` prime == (a + b) `op_Modulus` prime /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM
(va_update_flags va_sM
(va_update_mem_layout va_sM
(va_update_mem_heaplet 0
va_sM
(va_update_reg64 rR11
va_sM
(va_update_reg64 rR10
va_sM
(va_update_reg64 rR9
va_sM
(va_update_reg64 rR8
va_sM
(va_update_reg64 rRdx
va_sM
(va_update_reg64 rRcx
va_sM
(va_update_reg64 rRax
va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))
))) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Memory.buffer64",
"Vale.X64.Decls.va_fuel",
"Prims.l_and",
"Vale.Curve25519.X64.FastHybrid.va_req_Fadd",
"Vale.X64.Decls.va_ensure_total",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Vale.Curve25519.Fast_defs.prime",
"Prims.op_Addition",
"Vale.X64.Decls.modifies_buffer",
"Vale.X64.Decls.va_get_mem",
"Prims.nat",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.buffer64_read",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_mem_layout",
"Vale.X64.Decls.va_update_mem_heaplet",
"Vale.X64.Decls.va_update_reg64",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_mem",
"Prims.prop"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) | false | true | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_ens_Fadd
(va_b0: va_code)
(va_s0: va_state)
(dst_b inA_b inB_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | [] | Vale.Curve25519.X64.FastHybrid.va_ens_Fadd | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_b: Vale.X64.Memory.buffer64 ->
va_sM: Vale.X64.Decls.va_state ->
va_fM: Vale.X64.Decls.va_fuel
-> Prims.prop | {
"end_col": 91,
"end_line": 186,
"start_col": 2,
"start_line": 166
} |
Prims.Tot | val va_req_Fadd (va_b0: va_code) (va_s0: va_state) (dst_b inA_b inB_b: buffer64) : prop | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)) | val va_req_Fadd (va_b0: va_code) (va_s0: va_state) (dst_b inA_b inB_b: buffer64) : prop
let va_req_Fadd (va_b0: va_code) (va_s0: va_state) (dst_b inA_b inB_b: buffer64) : prop = | false | null | false | (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\
(let a0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let b0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let b1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let b2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let b3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let a:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let b:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in
adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdi va_s0)
dst_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0)
inA_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdx va_s0)
inB_b
4
(va_get_mem_layout va_s0)
Secret)) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Memory.buffer64",
"Prims.l_and",
"Vale.X64.Decls.va_require_total",
"Vale.Curve25519.X64.FastHybrid.va_code_Fadd",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Prims.l_or",
"Vale.X64.Decls.buffers_disjoint",
"Prims.eq2",
"Vale.X64.Decls.validDstAddrs64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdi",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validSrcAddrs64",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRdx",
"Prims.nat",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.buffer64_read",
"Prims.prop"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) | false | true | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_req_Fadd (va_b0: va_code) (va_s0: va_state) (dst_b inA_b inB_b: buffer64) : prop | [] | Vale.Curve25519.X64.FastHybrid.va_req_Fadd | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_b: Vale.X64.Memory.buffer64
-> Prims.prop | {
"end_col": 38,
"end_line": 163,
"start_col": 2,
"start_line": 145
} |
Prims.Tot | val va_wp_Fadd (dst_b inA_b inB_b: buffer64) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (()))) | val va_wp_Fadd (dst_b inA_b inB_b: buffer64) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Fadd (dst_b inA_b inB_b: buffer64) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_get_ok va_s0 /\
(let a0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let b0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let b1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let b2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let b3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let a:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let b:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in
adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdi va_s0)
dst_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0)
inA_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdx va_s0)
inB_b
4
(va_get_mem_layout va_s0)
Secret) /\
(forall (va_x_mem: vale_heap) (va_x_rax: nat64) (va_x_rcx: nat64) (va_x_rdx: nat64)
(va_x_r8: nat64) (va_x_r9: nat64) (va_x_r10: nat64) (va_x_r11: nat64) (va_x_heap0: vale_heap)
(va_x_memLayout: vale_heap_layout) (va_x_efl: Vale.X64.Flags.t).
let va_sM =
va_upd_flags va_x_efl
(va_upd_mem_layout va_x_memLayout
(va_upd_mem_heaplet 0
va_x_heap0
(va_upd_reg64 rR11
va_x_r11
(va_upd_reg64 rR10
va_x_r10
(va_upd_reg64 rR9
va_x_r9
(va_upd_reg64 rR8
va_x_r8
(va_upd_reg64 rRdx
va_x_rdx
(va_upd_reg64 rRcx
va_x_rcx
(va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))
))))))
in
va_get_ok va_sM /\
(let a0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let b0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let b1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let b2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let b3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let a:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let b:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in
let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in
let d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in
let d3 = Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in
let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in
d `op_Modulus` prime == (a + b) `op_Modulus` prime /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Vale.X64.Memory.buffer64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Prims.l_or",
"Vale.X64.Decls.buffers_disjoint",
"Prims.eq2",
"Vale.X64.Decls.validDstAddrs64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdi",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validSrcAddrs64",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRdx",
"Prims.nat",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.buffer64_read",
"Prims.l_Forall",
"Vale.X64.InsBasic.vale_heap",
"Vale.X64.Memory.nat64",
"Vale.Arch.HeapImpl.vale_heap_layout",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Prims.int",
"Prims.op_Modulus",
"Vale.Curve25519.Fast_defs.prime",
"Prims.op_Addition",
"Vale.X64.Decls.modifies_buffer",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_mem_layout",
"Vale.X64.Decls.va_upd_mem_heaplet",
"Vale.X64.Decls.va_upd_reg64",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_upd_mem"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state | false | true | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Fadd (dst_b inA_b inB_b: buffer64) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.Curve25519.X64.FastHybrid.va_wp_Fadd | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_b: Vale.X64.Memory.buffer64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 16,
"end_line": 273,
"start_col": 2,
"start_line": 233
} |
Prims.Tot | val va_req_Fsub (va_b0: va_code) (va_s0: va_state) (dst_b inA_b inB_b: buffer64) : prop | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_req_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)) | val va_req_Fsub (va_b0: va_code) (va_s0: va_state) (dst_b inA_b inB_b: buffer64) : prop
let va_req_Fsub (va_b0: va_code) (va_s0: va_state) (dst_b inA_b inB_b: buffer64) : prop = | false | null | false | (va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\
(let a0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let b0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let b1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let b2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let b3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let a:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let b:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in
adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdi va_s0)
dst_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0)
inA_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdx va_s0)
inB_b
4
(va_get_mem_layout va_s0)
Secret)) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Memory.buffer64",
"Prims.l_and",
"Vale.X64.Decls.va_require_total",
"Vale.Curve25519.X64.FastHybrid.va_code_Fsub",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Prims.l_or",
"Vale.X64.Decls.buffers_disjoint",
"Prims.eq2",
"Vale.X64.Decls.validDstAddrs64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdi",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validSrcAddrs64",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRdx",
"Prims.nat",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.buffer64_read",
"Prims.prop"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b))
//--
//-- Fadd_stdcall
val va_code_Fadd_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fadd_stdcall : win:bool -> Tot va_pbool
let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fadd_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fadd_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fadd_stdcall win)) =
(va_QProc (va_code_Fadd_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fadd_stdcall win dst_b inA_b inB_b))
//--
//-- Fsub
val va_code_Fsub : va_dummy:unit -> Tot va_code
val va_codegen_success_Fsub : va_dummy:unit -> Tot va_pbool
let va_req_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) | false | true | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_req_Fsub (va_b0: va_code) (va_s0: va_state) (dst_b inA_b inB_b: buffer64) : prop | [] | Vale.Curve25519.X64.FastHybrid.va_req_Fsub | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_b: Vale.X64.Memory.buffer64
-> Prims.prop | {
"end_col": 38,
"end_line": 510,
"start_col": 2,
"start_line": 492
} |
Prims.Tot | val va_ens_Fsub
(va_b0: va_code)
(va_s0: va_state)
(dst_b inA_b inB_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_ens_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))) | val va_ens_Fsub
(va_b0: va_code)
(va_s0: va_state)
(dst_b inA_b inB_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop
let va_ens_Fsub
(va_b0: va_code)
(va_s0: va_state)
(dst_b inA_b inB_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop = | false | null | false | (va_req_Fsub va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\
(let a0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let b0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let b1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let b2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let b3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let a:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let b:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in
let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in
let d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in
let d3 = Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in
let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in
d `op_Modulus` prime == (a - b) `op_Modulus` prime /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM
(va_update_flags va_sM
(va_update_mem_layout va_sM
(va_update_mem_heaplet 0
va_sM
(va_update_reg64 rR11
va_sM
(va_update_reg64 rR10
va_sM
(va_update_reg64 rR9
va_sM
(va_update_reg64 rR8
va_sM
(va_update_reg64 rRcx
va_sM
(va_update_reg64 rRax
va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Memory.buffer64",
"Vale.X64.Decls.va_fuel",
"Prims.l_and",
"Vale.Curve25519.X64.FastHybrid.va_req_Fsub",
"Vale.X64.Decls.va_ensure_total",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Vale.Curve25519.Fast_defs.prime",
"Prims.op_Subtraction",
"Vale.X64.Decls.modifies_buffer",
"Vale.X64.Decls.va_get_mem",
"Prims.nat",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.buffer64_read",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_mem_layout",
"Vale.X64.Decls.va_update_mem_heaplet",
"Vale.X64.Decls.va_update_reg64",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_mem",
"Prims.prop"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b))
//--
//-- Fadd_stdcall
val va_code_Fadd_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fadd_stdcall : win:bool -> Tot va_pbool
let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fadd_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fadd_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fadd_stdcall win)) =
(va_QProc (va_code_Fadd_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fadd_stdcall win dst_b inA_b inB_b))
//--
//-- Fsub
val va_code_Fsub : va_dummy:unit -> Tot va_code
val va_codegen_success_Fsub : va_dummy:unit -> Tot va_pbool
let va_req_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) | false | true | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_ens_Fsub
(va_b0: va_code)
(va_s0: va_state)
(dst_b inA_b inB_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | [] | Vale.Curve25519.X64.FastHybrid.va_ens_Fsub | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_b: Vale.X64.Memory.buffer64 ->
va_sM: Vale.X64.Decls.va_state ->
va_fM: Vale.X64.Decls.va_fuel
-> Prims.prop | {
"end_col": 62,
"end_line": 533,
"start_col": 2,
"start_line": 513
} |
Prims.Tot | val va_wp_Fsub (dst_b inA_b inB_b: buffer64) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_wp_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9
(va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem
va_x_mem va_s0))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (()))) | val va_wp_Fsub (dst_b inA_b inB_b: buffer64) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Fsub (dst_b inA_b inB_b: buffer64) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_get_ok va_s0 /\
(let a0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let b0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let b1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let b2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let b3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let a:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let b:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in
adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdi va_s0)
dst_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0)
inA_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdx va_s0)
inB_b
4
(va_get_mem_layout va_s0)
Secret) /\
(forall (va_x_mem: vale_heap) (va_x_rax: nat64) (va_x_rcx: nat64) (va_x_r8: nat64)
(va_x_r9: nat64) (va_x_r10: nat64) (va_x_r11: nat64) (va_x_heap0: vale_heap)
(va_x_memLayout: vale_heap_layout) (va_x_efl: Vale.X64.Flags.t).
let va_sM =
va_upd_flags va_x_efl
(va_upd_mem_layout va_x_memLayout
(va_upd_mem_heaplet 0
va_x_heap0
(va_upd_reg64 rR11
va_x_r11
(va_upd_reg64 rR10
va_x_r10
(va_upd_reg64 rR9
va_x_r9
(va_upd_reg64 rR8
va_x_r8
(va_upd_reg64 rRcx
va_x_rcx
(va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))
)
in
va_get_ok va_sM /\
(let a0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let b0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let b1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let b2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let b3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let a:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let b:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in
let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in
let d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in
let d3 = Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in
let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in
d `op_Modulus` prime == (a - b) `op_Modulus` prime /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Vale.X64.Memory.buffer64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Prims.l_or",
"Vale.X64.Decls.buffers_disjoint",
"Prims.eq2",
"Vale.X64.Decls.validDstAddrs64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdi",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validSrcAddrs64",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRdx",
"Prims.nat",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.buffer64_read",
"Prims.l_Forall",
"Vale.X64.InsBasic.vale_heap",
"Vale.X64.Memory.nat64",
"Vale.Arch.HeapImpl.vale_heap_layout",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Prims.int",
"Prims.op_Modulus",
"Vale.Curve25519.Fast_defs.prime",
"Prims.op_Subtraction",
"Vale.X64.Decls.modifies_buffer",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_mem_layout",
"Vale.X64.Decls.va_upd_mem_heaplet",
"Vale.X64.Decls.va_upd_reg64",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_upd_mem"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b))
//--
//-- Fadd_stdcall
val va_code_Fadd_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fadd_stdcall : win:bool -> Tot va_pbool
let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fadd_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fadd_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fadd_stdcall win)) =
(va_QProc (va_code_Fadd_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fadd_stdcall win dst_b inA_b inB_b))
//--
//-- Fsub
val va_code_Fsub : va_dummy:unit -> Tot va_code
val va_codegen_success_Fsub : va_dummy:unit -> Tot va_pbool
let va_req_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fsub : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state | false | true | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Fsub (dst_b inA_b inB_b: buffer64) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.Curve25519.X64.FastHybrid.va_wp_Fsub | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_b: Vale.X64.Memory.buffer64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 16,
"end_line": 619,
"start_col": 2,
"start_line": 580
} |
Prims.Tot | val va_req_Fmul1 (va_b0: va_code) (va_s0: va_state) (dst_b inA_b: buffer64) (inB: nat64) : prop | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_req_Fmul1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) :
prop =
(va_require_total va_b0 (va_code_Fmul1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ va_get_reg64
rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b
inA_b \/ dst_b == inA_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64
rRdi va_s0) dst_b 4 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
va_get_reg64 rRdx va_s0 < 131072)) | val va_req_Fmul1 (va_b0: va_code) (va_s0: va_state) (dst_b inA_b: buffer64) (inB: nat64) : prop
let va_req_Fmul1 (va_b0: va_code) (va_s0: va_state) (dst_b inA_b: buffer64) (inB: nat64) : prop = | false | null | false | (va_require_total va_b0 (va_code_Fmul1 ()) va_s0 /\ va_get_ok va_s0 /\
(let a0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let a:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
va_get_reg64 rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdi va_s0)
dst_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0)
inA_b
4
(va_get_mem_layout va_s0)
Secret /\ va_get_reg64 rRdx va_s0 < 131072)) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Memory.buffer64",
"Vale.X64.Memory.nat64",
"Prims.l_and",
"Vale.X64.Decls.va_require_total",
"Vale.Curve25519.X64.FastHybrid.va_code_Fmul1",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled",
"Prims.l_or",
"Vale.X64.Decls.buffers_disjoint",
"Vale.X64.Decls.validDstAddrs64",
"Vale.X64.Machine_s.rRdi",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validSrcAddrs64",
"Vale.X64.Machine_s.rRsi",
"Prims.op_LessThan",
"Prims.nat",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.X64.Decls.buffer64_read",
"Prims.prop"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b))
//--
//-- Fadd_stdcall
val va_code_Fadd_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fadd_stdcall : win:bool -> Tot va_pbool
let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fadd_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fadd_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fadd_stdcall win)) =
(va_QProc (va_code_Fadd_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fadd_stdcall win dst_b inA_b inB_b))
//--
//-- Fsub
val va_code_Fsub : va_dummy:unit -> Tot va_code
val va_codegen_success_Fsub : va_dummy:unit -> Tot va_pbool
let va_req_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fsub : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9
(va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem
va_x_mem va_s0))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fsub : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fsub ())) =
(va_QProc (va_code_Fsub ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) (va_wp_Fsub dst_b inA_b inB_b) (va_wpProof_Fsub dst_b inA_b inB_b))
//--
//-- Fsub_stdcall
val va_code_Fsub_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fsub_stdcall : win:bool -> Tot va_pbool
let va_req_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fsub_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fsub_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fsub_stdcall win)) =
(va_QProc (va_code_Fsub_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fsub_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fsub_stdcall win dst_b inA_b inB_b))
//--
//-- Fmul1
val va_code_Fmul1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fmul1 : va_dummy:unit -> Tot va_pbool
let va_req_Fmul1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) : | false | true | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_req_Fmul1 (va_b0: va_code) (va_s0: va_state) (dst_b inA_b: buffer64) (inB: nat64) : prop | [] | Vale.Curve25519.X64.FastHybrid.va_req_Fmul1 | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB: Vale.X64.Memory.nat64
-> Prims.prop | {
"end_col": 38,
"end_line": 848,
"start_col": 2,
"start_line": 837
} |
Prims.Tot | val va_ens_Fmul1
(va_b0: va_code)
(va_s0: va_state)
(dst_b inA_b: buffer64)
(inB: nat64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_ens_Fmul1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fmul1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok
va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem
va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem
va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem
va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem
va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a
(va_get_reg64 rRdx va_s0) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem va_s0) (va_get_mem va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM
(va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))) | val va_ens_Fmul1
(va_b0: va_code)
(va_s0: va_state)
(dst_b inA_b: buffer64)
(inB: nat64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop
let va_ens_Fmul1
(va_b0: va_code)
(va_s0: va_state)
(dst_b inA_b: buffer64)
(inB: nat64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop = | false | null | false | (va_req_Fmul1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\
(let a0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let a:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in
let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in
let d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in
let d3 = Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in
let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in
d `op_Modulus` prime == (va_mul_nat a (va_get_reg64 rRdx va_s0)) `op_Modulus` prime /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM
(va_update_flags va_sM
(va_update_mem_layout va_sM
(va_update_mem_heaplet 0
va_sM
(va_update_reg64 rR13
va_sM
(va_update_reg64 rRbx
va_sM
(va_update_reg64 rR11
va_sM
(va_update_reg64 rR10
va_sM
(va_update_reg64 rR9
va_sM
(va_update_reg64 rR8
va_sM
(va_update_reg64 rRdx
va_sM
(va_update_reg64 rRcx
va_sM
(va_update_reg64 rRax
va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))
))))))))))))) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Memory.buffer64",
"Vale.X64.Memory.nat64",
"Vale.X64.Decls.va_fuel",
"Prims.l_and",
"Vale.Curve25519.X64.FastHybrid.va_req_Fmul1",
"Vale.X64.Decls.va_ensure_total",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Vale.Curve25519.Fast_defs.prime",
"Vale.X64.Decls.va_mul_nat",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Decls.modifies_buffer",
"Vale.X64.Decls.va_get_mem",
"Prims.nat",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.buffer64_read",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_mem_layout",
"Vale.X64.Decls.va_update_mem_heaplet",
"Vale.X64.Decls.va_update_reg64",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_mem",
"Prims.prop"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b))
//--
//-- Fadd_stdcall
val va_code_Fadd_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fadd_stdcall : win:bool -> Tot va_pbool
let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fadd_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fadd_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fadd_stdcall win)) =
(va_QProc (va_code_Fadd_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fadd_stdcall win dst_b inA_b inB_b))
//--
//-- Fsub
val va_code_Fsub : va_dummy:unit -> Tot va_code
val va_codegen_success_Fsub : va_dummy:unit -> Tot va_pbool
let va_req_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fsub : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9
(va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem
va_x_mem va_s0))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fsub : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fsub ())) =
(va_QProc (va_code_Fsub ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) (va_wp_Fsub dst_b inA_b inB_b) (va_wpProof_Fsub dst_b inA_b inB_b))
//--
//-- Fsub_stdcall
val va_code_Fsub_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fsub_stdcall : win:bool -> Tot va_pbool
let va_req_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fsub_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fsub_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fsub_stdcall win)) =
(va_QProc (va_code_Fsub_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fsub_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fsub_stdcall win dst_b inA_b inB_b))
//--
//-- Fmul1
val va_code_Fmul1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fmul1 : va_dummy:unit -> Tot va_pbool
let va_req_Fmul1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) :
prop =
(va_require_total va_b0 (va_code_Fmul1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ va_get_reg64
rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b
inA_b \/ dst_b == inA_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64
rRdi va_s0) dst_b 4 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
va_get_reg64 rRdx va_s0 < 131072))
let va_ens_Fmul1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) | false | true | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_ens_Fmul1
(va_b0: va_code)
(va_s0: va_state)
(dst_b inA_b: buffer64)
(inB: nat64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | [] | Vale.Curve25519.X64.FastHybrid.va_ens_Fmul1 | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB: Vale.X64.Memory.nat64 ->
va_sM: Vale.X64.Decls.va_state ->
va_fM: Vale.X64.Decls.va_fuel
-> Prims.prop | {
"end_col": 30,
"end_line": 868,
"start_col": 2,
"start_line": 851
} |
Prims.Tot | val va_wp_Fmul1
(dst_b inA_b: buffer64)
(inB: nat64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_wp_Fmul1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ va_get_reg64
rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b
inA_b \/ dst_b == inA_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64
rRdi va_s0) dst_b 4 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
va_get_reg64 rRdx va_s0 < 131072) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR13
va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10
(va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64
rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))))) in va_get_ok
va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem
va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem
va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem
va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem
va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a
(va_get_reg64 rRdx va_s0) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k va_sM (()))) | val va_wp_Fmul1
(dst_b inA_b: buffer64)
(inB: nat64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Fmul1
(dst_b inA_b: buffer64)
(inB: nat64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_get_ok va_s0 /\
(let a0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let a:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
va_get_reg64 rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRdi va_s0)
dst_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0)
inA_b
4
(va_get_mem_layout va_s0)
Secret /\ va_get_reg64 rRdx va_s0 < 131072) /\
(forall (va_x_mem: vale_heap) (va_x_rax: nat64) (va_x_rcx: nat64) (va_x_rdx: nat64)
(va_x_r8: nat64) (va_x_r9: nat64) (va_x_r10: nat64) (va_x_r11: nat64) (va_x_rbx: nat64)
(va_x_r13: nat64) (va_x_heap0: vale_heap) (va_x_memLayout: vale_heap_layout)
(va_x_efl: Vale.X64.Flags.t).
let va_sM =
va_upd_flags va_x_efl
(va_upd_mem_layout va_x_memLayout
(va_upd_mem_heaplet 0
va_x_heap0
(va_upd_reg64 rR13
va_x_r13
(va_upd_reg64 rRbx
va_x_rbx
(va_upd_reg64 rR11
va_x_r11
(va_upd_reg64 rR10
va_x_r10
(va_upd_reg64 rR9
va_x_r9
(va_upd_reg64 rR8
va_x_r8
(va_upd_reg64 rRdx
va_x_rdx
(va_upd_reg64 rRcx
va_x_rcx
(va_upd_reg64 rRax
va_x_rax
(va_upd_mem va_x_mem va_s0))))))))))))
in
va_get_ok va_sM /\
(let a0:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3:Vale.Def.Types_s.nat64 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let a:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in
let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in
let d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in
let d3 = Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in
let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in
d `op_Modulus` prime == (va_mul_nat a (va_get_reg64 rRdx va_s0)) `op_Modulus` prime /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Vale.X64.Memory.buffer64",
"Vale.X64.Memory.nat64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled",
"Prims.l_or",
"Vale.X64.Decls.buffers_disjoint",
"Vale.X64.Decls.validDstAddrs64",
"Vale.X64.Machine_s.rRdi",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validSrcAddrs64",
"Vale.X64.Machine_s.rRsi",
"Prims.op_LessThan",
"Prims.nat",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.X64.Decls.buffer64_read",
"Prims.l_Forall",
"Vale.X64.InsBasic.vale_heap",
"Vale.Arch.HeapImpl.vale_heap_layout",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Prims.int",
"Prims.op_Modulus",
"Vale.Curve25519.Fast_defs.prime",
"Vale.X64.Decls.va_mul_nat",
"Vale.X64.Decls.modifies_buffer",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_mem_layout",
"Vale.X64.Decls.va_upd_mem_heaplet",
"Vale.X64.Decls.va_upd_reg64",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_upd_mem"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b))
//--
//-- Fadd_stdcall
val va_code_Fadd_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fadd_stdcall : win:bool -> Tot va_pbool
let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fadd_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fadd_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fadd_stdcall win)) =
(va_QProc (va_code_Fadd_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fadd_stdcall win dst_b inA_b inB_b))
//--
//-- Fsub
val va_code_Fsub : va_dummy:unit -> Tot va_code
val va_codegen_success_Fsub : va_dummy:unit -> Tot va_pbool
let va_req_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fsub : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9
(va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem
va_x_mem va_s0))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fsub : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fsub ())) =
(va_QProc (va_code_Fsub ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) (va_wp_Fsub dst_b inA_b inB_b) (va_wpProof_Fsub dst_b inA_b inB_b))
//--
//-- Fsub_stdcall
val va_code_Fsub_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fsub_stdcall : win:bool -> Tot va_pbool
let va_req_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fsub_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fsub_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fsub_stdcall win)) =
(va_QProc (va_code_Fsub_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fsub_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fsub_stdcall win dst_b inA_b inB_b))
//--
//-- Fmul1
val va_code_Fmul1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fmul1 : va_dummy:unit -> Tot va_pbool
let va_req_Fmul1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) :
prop =
(va_require_total va_b0 (va_code_Fmul1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ va_get_reg64
rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b
inA_b \/ dst_b == inA_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64
rRdi va_s0) dst_b 4 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
va_get_reg64 rRdx va_s0 < 131072))
let va_ens_Fmul1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fmul1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok
va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem
va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem
va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem
va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem
va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a
(va_get_reg64 rRdx va_s0) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem va_s0) (va_get_mem va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM
(va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
val va_lemma_Fmul1 : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fmul1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ va_get_reg64
rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b
inA_b \/ dst_b == inA_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64
rRdi va_s0) dst_b 4 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
va_get_reg64 rRdx va_s0 < 131072)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a
(va_get_reg64 rRdx va_s0) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem va_s0) (va_get_mem va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM
(va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))
[@ va_qattr]
let va_wp_Fmul1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state -> | false | true | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Fmul1
(dst_b inA_b: buffer64)
(inB: nat64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.Curve25519.X64.FastHybrid.va_wp_Fmul1 | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB: Vale.X64.Memory.nat64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 64,
"end_line": 935,
"start_col": 2,
"start_line": 906
} |
Prims.Tot | val va_quick_Carry_wide (offset: nat) (dst_b inA_b: buffer64)
: (va_quickCode unit (va_code_Carry_wide offset)) | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b)) | val va_quick_Carry_wide (offset: nat) (dst_b inA_b: buffer64)
: (va_quickCode unit (va_code_Carry_wide offset))
let va_quick_Carry_wide (offset: nat) (dst_b inA_b: buffer64)
: (va_quickCode unit (va_code_Carry_wide offset)) = | false | null | false | (va_QProc (va_code_Carry_wide offset)
([
va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11;
va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRax; va_Mod_mem
])
(va_wp_Carry_wide offset dst_b inA_b)
(va_wpProof_Carry_wide offset dst_b inA_b)) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Prims.nat",
"Vale.X64.Memory.buffer64",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.Curve25519.X64.FastHybrid.va_code_Carry_wide",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_Mod_mem_heaplet",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.Curve25519.X64.FastHybrid.va_wp_Carry_wide",
"Vale.Curve25519.X64.FastHybrid.va_wpProof_Carry_wide",
"Vale.X64.QuickCode.va_quickCode"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit | false | false | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Carry_wide (offset: nat) (dst_b inA_b: buffer64)
: (va_quickCode unit (va_code_Carry_wide offset)) | [] | Vale.Curve25519.X64.FastHybrid.va_quick_Carry_wide | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | offset: Prims.nat -> dst_b: Vale.X64.Memory.buffer64 -> inA_b: Vale.X64.Memory.buffer64
-> Vale.X64.QuickCode.va_quickCode Prims.unit
(Vale.Curve25519.X64.FastHybrid.va_code_Carry_wide offset) | {
"end_col": 60,
"end_line": 136,
"start_col": 2,
"start_line": 133
} |
Prims.Tot | val va_quick_Fadd (dst_b inA_b inB_b: buffer64) : (va_quickCode unit (va_code_Fadd ())) | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b)) | val va_quick_Fadd (dst_b inA_b inB_b: buffer64) : (va_quickCode unit (va_code_Fadd ()))
let va_quick_Fadd (dst_b inA_b inB_b: buffer64) : (va_quickCode unit (va_code_Fadd ())) = | false | null | false | (va_QProc (va_code_Fadd ())
([
va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10;
va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax;
va_Mod_mem
])
(va_wp_Fadd dst_b inA_b inB_b)
(va_wpProof_Fadd dst_b inA_b inB_b)) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Vale.X64.Memory.buffer64",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.Curve25519.X64.FastHybrid.va_code_Fadd",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_Mod_mem_layout",
"Vale.X64.QuickCode.va_Mod_mem_heaplet",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.Curve25519.X64.FastHybrid.va_wp_Fadd",
"Vale.Curve25519.X64.FastHybrid.va_wpProof_Fadd",
"Vale.X64.QuickCode.va_quickCode"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit | false | false | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Fadd (dst_b inA_b inB_b: buffer64) : (va_quickCode unit (va_code_Fadd ())) | [] | Vale.Curve25519.X64.FastHybrid.va_quick_Fadd | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_b: Vale.X64.Memory.buffer64
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.Curve25519.X64.FastHybrid.va_code_Fadd ()) | {
"end_col": 17,
"end_line": 289,
"start_col": 2,
"start_line": 286
} |
Prims.Tot | val va_req_Fadd_stdcall (va_b0: va_code) (va_s0: va_state) (win: bool) (dst_b inA_b inB_b: buffer64)
: prop | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)) | val va_req_Fadd_stdcall (va_b0: va_code) (va_s0: va_state) (win: bool) (dst_b inA_b inB_b: buffer64)
: prop
let va_req_Fadd_stdcall (va_b0: va_code) (va_s0: va_state) (win: bool) (dst_b inA_b inB_b: buffer64)
: prop = | false | null | false | (va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\
(let dst_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0)
in
let inA_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0)
in
let inB_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0)
in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
dst_in
dst_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
inA_in
inA_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
inB_in
inB_b
4
(va_get_mem_layout va_s0)
Secret)) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Prims.l_and",
"Vale.X64.Decls.va_require_total",
"Vale.Curve25519.X64.FastHybrid.va_code_Fadd_stdcall",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Stack_i.init_rsp",
"Vale.X64.Decls.va_get_stack",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled",
"Prims.l_or",
"Vale.X64.Decls.buffers_disjoint",
"Vale.X64.Decls.validDstAddrs64",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validSrcAddrs64",
"Vale.X64.Decls.va_int_range",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRdi",
"Prims.prop"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b))
//--
//-- Fadd_stdcall
val va_code_Fadd_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fadd_stdcall : win:bool -> Tot va_pbool
let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64) | false | true | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_req_Fadd_stdcall (va_b0: va_code) (va_s0: va_state) (win: bool) (dst_b inA_b inB_b: buffer64)
: prop | [] | Vale.Curve25519.X64.FastHybrid.va_req_Fadd_stdcall | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
win: Prims.bool ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_b: Vale.X64.Memory.buffer64
-> Prims.prop | {
"end_col": 38,
"end_line": 310,
"start_col": 2,
"start_line": 298
} |
Prims.Tot | val va_ens_Fadd_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b inB_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_ens_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))) | val va_ens_Fadd_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b inB_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop
let va_ens_Fadd_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b inB_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop = | false | null | false | (va_req_Fadd_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\
(let dst_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0)
in
let inA_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0)
in
let inB_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0)
in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let b0 = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let b1 = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let b2 = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let b3 = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in
let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in
let d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in
let d3 = Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in
let a = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let b = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in
let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in
d `op_Modulus` prime == (a + b) `op_Modulus` prime /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\
(win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\
(win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\
(win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\
(win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
(~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\
(~win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\
(~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM
(va_update_stackTaint va_sM
(va_update_stack va_sM
(va_update_mem_layout va_sM
(va_update_mem_heaplet 0
va_sM
(va_update_flags va_sM
(va_update_reg64 rR15
va_sM
(va_update_reg64 rR14
va_sM
(va_update_reg64 rR13
va_sM
(va_update_reg64 rR11
va_sM
(va_update_reg64 rR10
va_sM
(va_update_reg64 rR9
va_sM
(va_update_reg64 rR8
va_sM
(va_update_reg64 rRsp
va_sM
(va_update_reg64 rRbp
va_sM
(va_update_reg64 rRdi
va_sM
(va_update_reg64 rRsi
va_sM
(va_update_reg64 rRdx
va_sM
(va_update_reg64 rRcx
va_sM
(va_update_reg64 rRbx
va_sM
(va_update_reg64 rRax
va_sM
(va_update_ok va_sM
(va_update_mem
va_sM
va_s0)))
)))))))))))))))))))) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.Decls.va_fuel",
"Prims.l_and",
"Vale.Curve25519.X64.FastHybrid.va_req_Fadd_stdcall",
"Vale.X64.Decls.va_ensure_total",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Vale.Curve25519.Fast_defs.prime",
"Prims.op_Addition",
"Vale.X64.Decls.modifies_buffer",
"Vale.X64.Decls.va_get_mem",
"Prims.l_imp",
"Vale.Def.Types_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRbp",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR15",
"Prims.l_not",
"Prims.nat",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.buffer64_read",
"Vale.X64.Decls.va_int_range",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_stackTaint",
"Vale.X64.Decls.va_update_stack",
"Vale.X64.Decls.va_update_mem_layout",
"Vale.X64.Decls.va_update_mem_heaplet",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_reg64",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_mem",
"Prims.prop"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b))
//--
//-- Fadd_stdcall
val va_code_Fadd_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fadd_stdcall : win:bool -> Tot va_pbool
let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64) | false | true | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_ens_Fadd_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b inB_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | [] | Vale.Curve25519.X64.FastHybrid.va_ens_Fadd_stdcall | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
win: Prims.bool ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_b: Vale.X64.Memory.buffer64 ->
va_sM: Vale.X64.Decls.va_state ->
va_fM: Vale.X64.Decls.va_fuel
-> Prims.prop | {
"end_col": 38,
"end_line": 350,
"start_col": 2,
"start_line": 313
} |
Prims.Tot | val va_quick_Fsub (dst_b inA_b inB_b: buffer64) : (va_quickCode unit (va_code_Fsub ())) | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_quick_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fsub ())) =
(va_QProc (va_code_Fsub ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) (va_wp_Fsub dst_b inA_b inB_b) (va_wpProof_Fsub dst_b inA_b inB_b)) | val va_quick_Fsub (dst_b inA_b inB_b: buffer64) : (va_quickCode unit (va_code_Fsub ()))
let va_quick_Fsub (dst_b inA_b inB_b: buffer64) : (va_quickCode unit (va_code_Fsub ())) = | false | null | false | (va_QProc (va_code_Fsub ())
([
va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10;
va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem
])
(va_wp_Fsub dst_b inA_b inB_b)
(va_wpProof_Fsub dst_b inA_b inB_b)) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Vale.X64.Memory.buffer64",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.Curve25519.X64.FastHybrid.va_code_Fsub",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_Mod_mem_layout",
"Vale.X64.QuickCode.va_Mod_mem_heaplet",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.Curve25519.X64.FastHybrid.va_wp_Fsub",
"Vale.Curve25519.X64.FastHybrid.va_wpProof_Fsub",
"Vale.X64.QuickCode.va_quickCode"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b))
//--
//-- Fadd_stdcall
val va_code_Fadd_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fadd_stdcall : win:bool -> Tot va_pbool
let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fadd_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fadd_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fadd_stdcall win)) =
(va_QProc (va_code_Fadd_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fadd_stdcall win dst_b inA_b inB_b))
//--
//-- Fsub
val va_code_Fsub : va_dummy:unit -> Tot va_code
val va_codegen_success_Fsub : va_dummy:unit -> Tot va_pbool
let va_req_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fsub : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9
(va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem
va_x_mem va_s0))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fsub : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit | false | false | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Fsub (dst_b inA_b inB_b: buffer64) : (va_quickCode unit (va_code_Fsub ())) | [] | Vale.Curve25519.X64.FastHybrid.va_quick_Fsub | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_b: Vale.X64.Memory.buffer64
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.Curve25519.X64.FastHybrid.va_code_Fsub ()) | {
"end_col": 90,
"end_line": 634,
"start_col": 2,
"start_line": 632
} |
Prims.Tot | val va_quick_Fadd_stdcall (win: bool) (dst_b inA_b inB_b: buffer64)
: (va_quickCode unit (va_code_Fadd_stdcall win)) | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_quick_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fadd_stdcall win)) =
(va_QProc (va_code_Fadd_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fadd_stdcall win dst_b inA_b inB_b)) | val va_quick_Fadd_stdcall (win: bool) (dst_b inA_b inB_b: buffer64)
: (va_quickCode unit (va_code_Fadd_stdcall win))
let va_quick_Fadd_stdcall (win: bool) (dst_b inA_b inB_b: buffer64)
: (va_quickCode unit (va_code_Fadd_stdcall win)) = | false | null | false | (va_QProc (va_code_Fadd_stdcall win)
([
va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11;
va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp;
va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem
])
(va_wp_Fadd_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fadd_stdcall win dst_b inA_b inB_b)) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.Curve25519.X64.FastHybrid.va_code_Fadd_stdcall",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_stackTaint",
"Vale.X64.QuickCode.va_Mod_stack",
"Vale.X64.QuickCode.va_Mod_mem_layout",
"Vale.X64.QuickCode.va_Mod_mem_heaplet",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rR15",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Machine_s.rRbp",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.Curve25519.X64.FastHybrid.va_wp_Fadd_stdcall",
"Vale.Curve25519.X64.FastHybrid.va_wpProof_Fadd_stdcall",
"Vale.X64.QuickCode.va_quickCode"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b))
//--
//-- Fadd_stdcall
val va_code_Fadd_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fadd_stdcall : win:bool -> Tot va_pbool
let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fadd_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fadd_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : | false | false | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Fadd_stdcall (win: bool) (dst_b inA_b inB_b: buffer64)
: (va_quickCode unit (va_code_Fadd_stdcall win)) | [] | Vale.Curve25519.X64.FastHybrid.va_quick_Fadd_stdcall | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
win: Prims.bool ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_b: Vale.X64.Memory.buffer64
-> Vale.X64.QuickCode.va_quickCode Prims.unit
(Vale.Curve25519.X64.FastHybrid.va_code_Fadd_stdcall win) | {
"end_col": 52,
"end_line": 483,
"start_col": 2,
"start_line": 478
} |
Prims.Tot | val va_req_Fsub_stdcall (va_b0: va_code) (va_s0: va_state) (win: bool) (dst_b inA_b inB_b: buffer64)
: prop | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_req_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)) | val va_req_Fsub_stdcall (va_b0: va_code) (va_s0: va_state) (win: bool) (dst_b inA_b inB_b: buffer64)
: prop
let va_req_Fsub_stdcall (va_b0: va_code) (va_s0: va_state) (win: bool) (dst_b inA_b inB_b: buffer64)
: prop = | false | null | false | (va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\
(let dst_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0)
in
let inA_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0)
in
let inB_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0)
in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
dst_in
dst_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
inA_in
inA_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
inB_in
inB_b
4
(va_get_mem_layout va_s0)
Secret)) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Prims.l_and",
"Vale.X64.Decls.va_require_total",
"Vale.Curve25519.X64.FastHybrid.va_code_Fsub_stdcall",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Stack_i.init_rsp",
"Vale.X64.Decls.va_get_stack",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled",
"Prims.l_or",
"Vale.X64.Decls.buffers_disjoint",
"Vale.X64.Decls.validDstAddrs64",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validSrcAddrs64",
"Vale.X64.Decls.va_int_range",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRdi",
"Prims.prop"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b))
//--
//-- Fadd_stdcall
val va_code_Fadd_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fadd_stdcall : win:bool -> Tot va_pbool
let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fadd_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fadd_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fadd_stdcall win)) =
(va_QProc (va_code_Fadd_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fadd_stdcall win dst_b inA_b inB_b))
//--
//-- Fsub
val va_code_Fsub : va_dummy:unit -> Tot va_code
val va_codegen_success_Fsub : va_dummy:unit -> Tot va_pbool
let va_req_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fsub : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9
(va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem
va_x_mem va_s0))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fsub : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fsub ())) =
(va_QProc (va_code_Fsub ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) (va_wp_Fsub dst_b inA_b inB_b) (va_wpProof_Fsub dst_b inA_b inB_b))
//--
//-- Fsub_stdcall
val va_code_Fsub_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fsub_stdcall : win:bool -> Tot va_pbool
let va_req_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64) | false | true | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_req_Fsub_stdcall (va_b0: va_code) (va_s0: va_state) (win: bool) (dst_b inA_b inB_b: buffer64)
: prop | [] | Vale.Curve25519.X64.FastHybrid.va_req_Fsub_stdcall | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
win: Prims.bool ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_b: Vale.X64.Memory.buffer64
-> Prims.prop | {
"end_col": 38,
"end_line": 655,
"start_col": 2,
"start_line": 643
} |
Prims.Tot | val va_wp_Carry_wide
(offset: nat)
(dst_b inA_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (()))) | val va_wp_Carry_wide
(offset: nat)
(dst_b inA_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Carry_wide
(offset: nat)
(dst_b inA_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_get_ok va_s0 /\
(let a0:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0)
in
let a1:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0)
in
let a2:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0)
in
let a3:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0)
in
let a4:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0)
in
let a5:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0)
in
let a6:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0)
in
let a7:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0)
in
let a:Prims.nat = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in
adx_enabled /\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rRdi va_s0)
dst_b
(4 + offset)
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rRsi va_s0)
inA_b
(8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0)
Secret) /\
(forall (va_x_mem: vale_heap) (va_x_rax: nat64) (va_x_rcx: nat64) (va_x_rdx: nat64)
(va_x_r8: nat64) (va_x_r9: nat64) (va_x_r10: nat64) (va_x_r11: nat64) (va_x_rbx: nat64)
(va_x_r13: nat64) (va_x_heap0: vale_heap) (va_x_efl: Vale.X64.Flags.t).
let va_sM =
va_upd_flags va_x_efl
(va_upd_mem_heaplet 0
va_x_heap0
(va_upd_reg64 rR13
va_x_r13
(va_upd_reg64 rRbx
va_x_rbx
(va_upd_reg64 rR11
va_x_r11
(va_upd_reg64 rR10
va_x_r10
(va_upd_reg64 rR9
va_x_r9
(va_upd_reg64 rR8
va_x_r8
(va_upd_reg64 rRdx
va_x_rdx
(va_upd_reg64 rRcx
va_x_rcx
(va_upd_reg64 rRax
va_x_rax
(va_upd_mem va_x_mem va_s0)))))))))))
in
va_get_ok va_sM /\
(let a0:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b
(0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0)
in
let a1:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b
(1 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0)
in
let a2:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b
(2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0)
in
let a3:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b
(3 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0)
in
let a4:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b
(4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0)
in
let a5:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b
(5 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0)
in
let a6:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b
(6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0)
in
let a7:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b
(7 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0)
in
let a:Prims.nat = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in
let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in
let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in
let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in
let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in
let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in
d `op_Modulus` prime == a `op_Modulus` prime /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM)
(va_get_reg64 rRdi va_sM)
dst_b
(4 + offset)
(va_get_mem_layout va_sM)
Secret /\
Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM)
(0 + offset)
(4 + offset - 1)) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Prims.nat",
"Vale.X64.Memory.buffer64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled",
"Prims.l_or",
"Prims.eq2",
"Prims.int",
"Vale.X64.Decls.buffers_disjoint",
"Vale.X64.Decls.validDstAddrs64",
"Vale.X64.Decls.va_get_mem_heaplet",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdi",
"Prims.op_Addition",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validSrcAddrs64",
"Vale.X64.Machine_s.rRsi",
"Prims.op_Multiply",
"Vale.Curve25519.Fast_defs.pow2_eight",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.buffer64_read",
"Prims.l_Forall",
"Vale.X64.InsBasic.vale_heap",
"Vale.X64.Memory.nat64",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Prims.op_Modulus",
"Vale.Curve25519.Fast_defs.prime",
"Vale.X64.Decls.modifies_buffer_specific",
"Prims.op_Subtraction",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_mem_heaplet",
"Vale.X64.Decls.va_upd_reg64",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_upd_mem"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state) | false | true | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Carry_wide
(offset: nat)
(dst_b inA_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.Curve25519.X64.FastHybrid.va_wp_Carry_wide | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
offset: Prims.nat ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 85,
"end_line": 120,
"start_col": 2,
"start_line": 75
} |
Prims.Tot | val va_quick_Fsub_stdcall (win: bool) (dst_b inA_b inB_b: buffer64)
: (va_quickCode unit (va_code_Fsub_stdcall win)) | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_quick_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fsub_stdcall win)) =
(va_QProc (va_code_Fsub_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fsub_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fsub_stdcall win dst_b inA_b inB_b)) | val va_quick_Fsub_stdcall (win: bool) (dst_b inA_b inB_b: buffer64)
: (va_quickCode unit (va_code_Fsub_stdcall win))
let va_quick_Fsub_stdcall (win: bool) (dst_b inA_b inB_b: buffer64)
: (va_quickCode unit (va_code_Fsub_stdcall win)) = | false | null | false | (va_QProc (va_code_Fsub_stdcall win)
([
va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11;
va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp;
va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem
])
(va_wp_Fsub_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fsub_stdcall win dst_b inA_b inB_b)) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.Curve25519.X64.FastHybrid.va_code_Fsub_stdcall",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_stackTaint",
"Vale.X64.QuickCode.va_Mod_stack",
"Vale.X64.QuickCode.va_Mod_mem_layout",
"Vale.X64.QuickCode.va_Mod_mem_heaplet",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rR15",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Machine_s.rRbp",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.Curve25519.X64.FastHybrid.va_wp_Fsub_stdcall",
"Vale.Curve25519.X64.FastHybrid.va_wpProof_Fsub_stdcall",
"Vale.X64.QuickCode.va_quickCode"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b))
//--
//-- Fadd_stdcall
val va_code_Fadd_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fadd_stdcall : win:bool -> Tot va_pbool
let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fadd_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fadd_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fadd_stdcall win)) =
(va_QProc (va_code_Fadd_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fadd_stdcall win dst_b inA_b inB_b))
//--
//-- Fsub
val va_code_Fsub : va_dummy:unit -> Tot va_code
val va_codegen_success_Fsub : va_dummy:unit -> Tot va_pbool
let va_req_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fsub : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9
(va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem
va_x_mem va_s0))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fsub : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fsub ())) =
(va_QProc (va_code_Fsub ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) (va_wp_Fsub dst_b inA_b inB_b) (va_wpProof_Fsub dst_b inA_b inB_b))
//--
//-- Fsub_stdcall
val va_code_Fsub_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fsub_stdcall : win:bool -> Tot va_pbool
let va_req_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fsub_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fsub_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : | false | false | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Fsub_stdcall (win: bool) (dst_b inA_b inB_b: buffer64)
: (va_quickCode unit (va_code_Fsub_stdcall win)) | [] | Vale.Curve25519.X64.FastHybrid.va_quick_Fsub_stdcall | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
win: Prims.bool ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_b: Vale.X64.Memory.buffer64
-> Vale.X64.QuickCode.va_quickCode Prims.unit
(Vale.Curve25519.X64.FastHybrid.va_code_Fsub_stdcall win) | {
"end_col": 52,
"end_line": 828,
"start_col": 2,
"start_line": 823
} |
Prims.Tot | val va_req_Fmul1_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
: prop | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_req_Fmul1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) : prop =
(va_require_total va_b0 (va_code_Fmul1_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret /\ inB_in < 131072)) | val va_req_Fmul1_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
: prop
let va_req_Fmul1_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
: prop = | false | null | false | (va_require_total va_b0 (va_code_Fmul1_stdcall win) va_s0 /\ va_get_ok va_s0 /\
(let dst_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0)
in
let inA_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0)
in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
inB_in = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
dst_in
dst_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
inA_in
inA_b
4
(va_get_mem_layout va_s0)
Secret /\ inB_in < 131072)) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.Memory.nat64",
"Prims.l_and",
"Vale.X64.Decls.va_require_total",
"Vale.Curve25519.X64.FastHybrid.va_code_Fmul1_stdcall",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Stack_i.init_rsp",
"Vale.X64.Decls.va_get_stack",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled",
"Prims.l_or",
"Vale.X64.Decls.buffers_disjoint",
"Prims.op_Equality",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Decls.validDstAddrs64",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validSrcAddrs64",
"Prims.op_LessThan",
"Vale.X64.Decls.va_int_range",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRdi",
"Prims.prop"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b))
//--
//-- Fadd_stdcall
val va_code_Fadd_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fadd_stdcall : win:bool -> Tot va_pbool
let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fadd_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fadd_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fadd_stdcall win)) =
(va_QProc (va_code_Fadd_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fadd_stdcall win dst_b inA_b inB_b))
//--
//-- Fsub
val va_code_Fsub : va_dummy:unit -> Tot va_code
val va_codegen_success_Fsub : va_dummy:unit -> Tot va_pbool
let va_req_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fsub : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9
(va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem
va_x_mem va_s0))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fsub : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fsub ())) =
(va_QProc (va_code_Fsub ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) (va_wp_Fsub dst_b inA_b inB_b) (va_wpProof_Fsub dst_b inA_b inB_b))
//--
//-- Fsub_stdcall
val va_code_Fsub_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fsub_stdcall : win:bool -> Tot va_pbool
let va_req_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fsub_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fsub_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fsub_stdcall win)) =
(va_QProc (va_code_Fsub_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fsub_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fsub_stdcall win dst_b inA_b inB_b))
//--
//-- Fmul1
val va_code_Fmul1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fmul1 : va_dummy:unit -> Tot va_pbool
let va_req_Fmul1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) :
prop =
(va_require_total va_b0 (va_code_Fmul1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ va_get_reg64
rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b
inA_b \/ dst_b == inA_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64
rRdi va_s0) dst_b 4 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
va_get_reg64 rRdx va_s0 < 131072))
let va_ens_Fmul1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fmul1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok
va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem
va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem
va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem
va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem
va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a
(va_get_reg64 rRdx va_s0) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem va_s0) (va_get_mem va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM
(va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
val va_lemma_Fmul1 : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fmul1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ va_get_reg64
rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b
inA_b \/ dst_b == inA_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64
rRdi va_s0) dst_b 4 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
va_get_reg64 rRdx va_s0 < 131072)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a
(va_get_reg64 rRdx va_s0) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem va_s0) (va_get_mem va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM
(va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))
[@ va_qattr]
let va_wp_Fmul1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ va_get_reg64
rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b
inA_b \/ dst_b == inA_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64
rRdi va_s0) dst_b 4 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
va_get_reg64 rRdx va_s0 < 131072) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR13
va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10
(va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64
rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))))) in va_get_ok
va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem
va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem
va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem
va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem
va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a
(va_get_reg64 rRdx va_s0) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k va_sM (())))
val va_wpProof_Fmul1 : dst_b:buffer64 -> inA_b:buffer64 -> inB:nat64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fmul1 dst_b inA_b inB va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fmul1 ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fmul1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) : (va_quickCode unit
(va_code_Fmul1 ())) =
(va_QProc (va_code_Fmul1 ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0;
va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
(va_wp_Fmul1 dst_b inA_b inB) (va_wpProof_Fmul1 dst_b inA_b inB))
//--
//-- Fmul1_stdcall
val va_code_Fmul1_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fmul1_stdcall : win:bool -> Tot va_pbool
let va_req_Fmul1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64) | false | true | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_req_Fmul1_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
: prop | [] | Vale.Curve25519.X64.FastHybrid.va_req_Fmul1_stdcall | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
win: Prims.bool ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_in: Vale.X64.Memory.nat64
-> Prims.prop | {
"end_col": 31,
"end_line": 970,
"start_col": 2,
"start_line": 960
} |
Prims.Tot | val va_quick_Fmul1 (dst_b inA_b: buffer64) (inB: nat64) : (va_quickCode unit (va_code_Fmul1 ())) | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_quick_Fmul1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) : (va_quickCode unit
(va_code_Fmul1 ())) =
(va_QProc (va_code_Fmul1 ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0;
va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
(va_wp_Fmul1 dst_b inA_b inB) (va_wpProof_Fmul1 dst_b inA_b inB)) | val va_quick_Fmul1 (dst_b inA_b: buffer64) (inB: nat64) : (va_quickCode unit (va_code_Fmul1 ()))
let va_quick_Fmul1 (dst_b inA_b: buffer64) (inB: nat64) : (va_quickCode unit (va_code_Fmul1 ())) = | false | null | false | (va_QProc (va_code_Fmul1 ())
([
va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx;
va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem
])
(va_wp_Fmul1 dst_b inA_b inB)
(va_wpProof_Fmul1 dst_b inA_b inB)) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Vale.X64.Memory.buffer64",
"Vale.X64.Memory.nat64",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.Curve25519.X64.FastHybrid.va_code_Fmul1",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_Mod_mem_layout",
"Vale.X64.QuickCode.va_Mod_mem_heaplet",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.Curve25519.X64.FastHybrid.va_wp_Fmul1",
"Vale.Curve25519.X64.FastHybrid.va_wpProof_Fmul1",
"Vale.X64.QuickCode.va_quickCode"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b))
//--
//-- Fadd_stdcall
val va_code_Fadd_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fadd_stdcall : win:bool -> Tot va_pbool
let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fadd_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fadd_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fadd_stdcall win)) =
(va_QProc (va_code_Fadd_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fadd_stdcall win dst_b inA_b inB_b))
//--
//-- Fsub
val va_code_Fsub : va_dummy:unit -> Tot va_code
val va_codegen_success_Fsub : va_dummy:unit -> Tot va_pbool
let va_req_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fsub : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9
(va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem
va_x_mem va_s0))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fsub : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fsub ())) =
(va_QProc (va_code_Fsub ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) (va_wp_Fsub dst_b inA_b inB_b) (va_wpProof_Fsub dst_b inA_b inB_b))
//--
//-- Fsub_stdcall
val va_code_Fsub_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fsub_stdcall : win:bool -> Tot va_pbool
let va_req_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fsub_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fsub_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fsub_stdcall win)) =
(va_QProc (va_code_Fsub_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fsub_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fsub_stdcall win dst_b inA_b inB_b))
//--
//-- Fmul1
val va_code_Fmul1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fmul1 : va_dummy:unit -> Tot va_pbool
let va_req_Fmul1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) :
prop =
(va_require_total va_b0 (va_code_Fmul1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ va_get_reg64
rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b
inA_b \/ dst_b == inA_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64
rRdi va_s0) dst_b 4 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
va_get_reg64 rRdx va_s0 < 131072))
let va_ens_Fmul1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fmul1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok
va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem
va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem
va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem
va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem
va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a
(va_get_reg64 rRdx va_s0) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem va_s0) (va_get_mem va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM
(va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
val va_lemma_Fmul1 : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fmul1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ va_get_reg64
rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b
inA_b \/ dst_b == inA_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64
rRdi va_s0) dst_b 4 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
va_get_reg64 rRdx va_s0 < 131072)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a
(va_get_reg64 rRdx va_s0) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem va_s0) (va_get_mem va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM
(va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))
[@ va_qattr]
let va_wp_Fmul1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ va_get_reg64
rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b
inA_b \/ dst_b == inA_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64
rRdi va_s0) dst_b 4 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
va_get_reg64 rRdx va_s0 < 131072) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR13
va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10
(va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64
rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))))) in va_get_ok
va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem
va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem
va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem
va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem
va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a
(va_get_reg64 rRdx va_s0) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k va_sM (())))
val va_wpProof_Fmul1 : dst_b:buffer64 -> inA_b:buffer64 -> inB:nat64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fmul1 dst_b inA_b inB va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fmul1 ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fmul1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) : (va_quickCode unit | false | false | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Fmul1 (dst_b inA_b: buffer64) (inB: nat64) : (va_quickCode unit (va_code_Fmul1 ())) | [] | Vale.Curve25519.X64.FastHybrid.va_quick_Fmul1 | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | dst_b: Vale.X64.Memory.buffer64 -> inA_b: Vale.X64.Memory.buffer64 -> inB: Vale.X64.Memory.nat64
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.Curve25519.X64.FastHybrid.va_code_Fmul1 ()) | {
"end_col": 69,
"end_line": 951,
"start_col": 2,
"start_line": 948
} |
Prims.Tot | val va_ens_Fsub_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b inB_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_ens_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))) | val va_ens_Fsub_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b inB_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop
let va_ens_Fsub_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b inB_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop = | false | null | false | (va_req_Fsub_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\
(let dst_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0)
in
let inA_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0)
in
let inB_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0)
in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let b0 = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let b1 = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let b2 = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let b3 = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in
let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in
let d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in
let d3 = Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in
let a = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let b = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in
let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in
d `op_Modulus` prime == (a - b) `op_Modulus` prime /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\
(win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\
(win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\
(win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\
(win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
(~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\
(~win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\
(~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM
(va_update_stackTaint va_sM
(va_update_stack va_sM
(va_update_mem_layout va_sM
(va_update_mem_heaplet 0
va_sM
(va_update_flags va_sM
(va_update_reg64 rR15
va_sM
(va_update_reg64 rR14
va_sM
(va_update_reg64 rR13
va_sM
(va_update_reg64 rR11
va_sM
(va_update_reg64 rR10
va_sM
(va_update_reg64 rR9
va_sM
(va_update_reg64 rR8
va_sM
(va_update_reg64 rRsp
va_sM
(va_update_reg64 rRbp
va_sM
(va_update_reg64 rRdi
va_sM
(va_update_reg64 rRsi
va_sM
(va_update_reg64 rRdx
va_sM
(va_update_reg64 rRcx
va_sM
(va_update_reg64 rRbx
va_sM
(va_update_reg64 rRax
va_sM
(va_update_ok va_sM
(va_update_mem
va_sM
va_s0)))
)))))))))))))))))))) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.Decls.va_fuel",
"Prims.l_and",
"Vale.Curve25519.X64.FastHybrid.va_req_Fsub_stdcall",
"Vale.X64.Decls.va_ensure_total",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Vale.Curve25519.Fast_defs.prime",
"Prims.op_Subtraction",
"Vale.X64.Decls.modifies_buffer",
"Vale.X64.Decls.va_get_mem",
"Prims.l_imp",
"Vale.Def.Types_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRbp",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR15",
"Prims.l_not",
"Prims.nat",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.buffer64_read",
"Vale.X64.Decls.va_int_range",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_stackTaint",
"Vale.X64.Decls.va_update_stack",
"Vale.X64.Decls.va_update_mem_layout",
"Vale.X64.Decls.va_update_mem_heaplet",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_reg64",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_mem",
"Prims.prop"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b))
//--
//-- Fadd_stdcall
val va_code_Fadd_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fadd_stdcall : win:bool -> Tot va_pbool
let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fadd_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fadd_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fadd_stdcall win)) =
(va_QProc (va_code_Fadd_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fadd_stdcall win dst_b inA_b inB_b))
//--
//-- Fsub
val va_code_Fsub : va_dummy:unit -> Tot va_code
val va_codegen_success_Fsub : va_dummy:unit -> Tot va_pbool
let va_req_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fsub : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9
(va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem
va_x_mem va_s0))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fsub : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fsub ())) =
(va_QProc (va_code_Fsub ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) (va_wp_Fsub dst_b inA_b inB_b) (va_wpProof_Fsub dst_b inA_b inB_b))
//--
//-- Fsub_stdcall
val va_code_Fsub_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fsub_stdcall : win:bool -> Tot va_pbool
let va_req_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64) | false | true | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_ens_Fsub_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b inB_b: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | [] | Vale.Curve25519.X64.FastHybrid.va_ens_Fsub_stdcall | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
win: Prims.bool ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_b: Vale.X64.Memory.buffer64 ->
va_sM: Vale.X64.Decls.va_state ->
va_fM: Vale.X64.Decls.va_fuel
-> Prims.prop | {
"end_col": 38,
"end_line": 695,
"start_col": 2,
"start_line": 658
} |
Prims.Tot | val va_quick_Fmul1_stdcall (win: bool) (dst_b inA_b: buffer64) (inB_in: nat64)
: (va_quickCode unit (va_code_Fmul1_stdcall win)) | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_quick_Fmul1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64) :
(va_quickCode unit (va_code_Fmul1_stdcall win)) =
(va_QProc (va_code_Fmul1_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fmul1_stdcall win dst_b inA_b inB_in)
(va_wpProof_Fmul1_stdcall win dst_b inA_b inB_in)) | val va_quick_Fmul1_stdcall (win: bool) (dst_b inA_b: buffer64) (inB_in: nat64)
: (va_quickCode unit (va_code_Fmul1_stdcall win))
let va_quick_Fmul1_stdcall (win: bool) (dst_b inA_b: buffer64) (inB_in: nat64)
: (va_quickCode unit (va_code_Fmul1_stdcall win)) = | false | null | false | (va_QProc (va_code_Fmul1_stdcall win)
([
va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11;
va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp;
va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem
])
(va_wp_Fmul1_stdcall win dst_b inA_b inB_in)
(va_wpProof_Fmul1_stdcall win dst_b inA_b inB_in)) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.Memory.nat64",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.Curve25519.X64.FastHybrid.va_code_Fmul1_stdcall",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_stackTaint",
"Vale.X64.QuickCode.va_Mod_stack",
"Vale.X64.QuickCode.va_Mod_mem_layout",
"Vale.X64.QuickCode.va_Mod_mem_heaplet",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rR15",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Machine_s.rRbp",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.Curve25519.X64.FastHybrid.va_wp_Fmul1_stdcall",
"Vale.Curve25519.X64.FastHybrid.va_wpProof_Fmul1_stdcall",
"Vale.X64.QuickCode.va_quickCode"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b))
//--
//-- Fadd_stdcall
val va_code_Fadd_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fadd_stdcall : win:bool -> Tot va_pbool
let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fadd_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fadd_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fadd_stdcall win)) =
(va_QProc (va_code_Fadd_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fadd_stdcall win dst_b inA_b inB_b))
//--
//-- Fsub
val va_code_Fsub : va_dummy:unit -> Tot va_code
val va_codegen_success_Fsub : va_dummy:unit -> Tot va_pbool
let va_req_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fsub : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9
(va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem
va_x_mem va_s0))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fsub : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fsub ())) =
(va_QProc (va_code_Fsub ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) (va_wp_Fsub dst_b inA_b inB_b) (va_wpProof_Fsub dst_b inA_b inB_b))
//--
//-- Fsub_stdcall
val va_code_Fsub_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fsub_stdcall : win:bool -> Tot va_pbool
let va_req_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fsub_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fsub_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fsub_stdcall win)) =
(va_QProc (va_code_Fsub_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fsub_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fsub_stdcall win dst_b inA_b inB_b))
//--
//-- Fmul1
val va_code_Fmul1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fmul1 : va_dummy:unit -> Tot va_pbool
let va_req_Fmul1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) :
prop =
(va_require_total va_b0 (va_code_Fmul1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ va_get_reg64
rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b
inA_b \/ dst_b == inA_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64
rRdi va_s0) dst_b 4 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
va_get_reg64 rRdx va_s0 < 131072))
let va_ens_Fmul1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fmul1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok
va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem
va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem
va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem
va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem
va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a
(va_get_reg64 rRdx va_s0) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem va_s0) (va_get_mem va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM
(va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
val va_lemma_Fmul1 : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fmul1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ va_get_reg64
rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b
inA_b \/ dst_b == inA_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64
rRdi va_s0) dst_b 4 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
va_get_reg64 rRdx va_s0 < 131072)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a
(va_get_reg64 rRdx va_s0) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem va_s0) (va_get_mem va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM
(va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))
[@ va_qattr]
let va_wp_Fmul1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ va_get_reg64
rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b
inA_b \/ dst_b == inA_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64
rRdi va_s0) dst_b 4 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
va_get_reg64 rRdx va_s0 < 131072) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR13
va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10
(va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64
rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))))) in va_get_ok
va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem
va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem
va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem
va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem
va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a
(va_get_reg64 rRdx va_s0) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k va_sM (())))
val va_wpProof_Fmul1 : dst_b:buffer64 -> inA_b:buffer64 -> inB:nat64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fmul1 dst_b inA_b inB va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fmul1 ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fmul1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) : (va_quickCode unit
(va_code_Fmul1 ())) =
(va_QProc (va_code_Fmul1 ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0;
va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
(va_wp_Fmul1 dst_b inA_b inB) (va_wpProof_Fmul1 dst_b inA_b inB))
//--
//-- Fmul1_stdcall
val va_code_Fmul1_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fmul1_stdcall : win:bool -> Tot va_pbool
let va_req_Fmul1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) : prop =
(va_require_total va_b0 (va_code_Fmul1_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret /\ inB_in < 131072))
let va_ens_Fmul1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fmul1_stdcall va_b0 va_s0 win dst_b inA_b inB_in /\ va_ensure_total va_b0 va_s0 va_sM
va_fM /\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_four
d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a inB_in `op_Modulus` prime /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\
(win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp
va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13
va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64
rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==>
va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM ==
va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint
va_sM (va_update_stack va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM
(va_update_flags va_sM (va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64
rR13 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fmul1_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_in:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fmul1_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret /\ inB_in < 131072)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let a0 = Vale.X64.Decls.buffer64_read
inA_b 0 (va_get_mem va_s0) in let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0)
in let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_four
d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a inB_in `op_Modulus` prime /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\
(win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp
va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13
va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64
rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==>
va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM ==
va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint
va_sM (va_update_stack va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM
(va_update_flags va_sM (va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64
rR13 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fmul1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in =
va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ inB_in < 131072) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let a0 =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_four
d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a inB_in `op_Modulus` prime /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\
(win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp
va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13
va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64
rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==>
va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM ==
va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==> va_k va_sM (())))
val va_wpProof_Fmul1_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_in:nat64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fmul1_stdcall win dst_b inA_b inB_in va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fmul1_stdcall win)
([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10;
va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi;
va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax;
va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fmul1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64) : | false | false | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Fmul1_stdcall (win: bool) (dst_b inA_b: buffer64) (inB_in: nat64)
: (va_quickCode unit (va_code_Fmul1_stdcall win)) | [] | Vale.Curve25519.X64.FastHybrid.va_quick_Fmul1_stdcall | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
win: Prims.bool ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_in: Vale.X64.Memory.nat64
-> Vale.X64.QuickCode.va_quickCode Prims.unit
(Vale.Curve25519.X64.FastHybrid.va_code_Fmul1_stdcall win) | {
"end_col": 54,
"end_line": 1119,
"start_col": 2,
"start_line": 1114
} |
Prims.Tot | val va_ens_Fmul1_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_ens_Fmul1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fmul1_stdcall va_b0 va_s0 win dst_b inA_b inB_in /\ va_ensure_total va_b0 va_s0 va_sM
va_fM /\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_four
d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a inB_in `op_Modulus` prime /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\
(win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp
va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13
va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64
rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==>
va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM ==
va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint
va_sM (va_update_stack va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM
(va_update_flags va_sM (va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64
rR13 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))) | val va_ens_Fmul1_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop
let va_ens_Fmul1_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop = | false | null | false | (va_req_Fmul1_stdcall va_b0 va_s0 win dst_b inA_b inB_in /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\
(let dst_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0)
in
let inA_in:(va_int_range 0 18446744073709551615) =
(if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0)
in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in
let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in
let d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in
let d3 = Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in
let a = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in
d `op_Modulus` prime == (va_mul_nat a inB_in) `op_Modulus` prime /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\
(win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\
(win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\
(win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\
(win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
(~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\
(~win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\
(~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM
(va_update_stackTaint va_sM
(va_update_stack va_sM
(va_update_mem_layout va_sM
(va_update_mem_heaplet 0
va_sM
(va_update_flags va_sM
(va_update_reg64 rR15
va_sM
(va_update_reg64 rR14
va_sM
(va_update_reg64 rR13
va_sM
(va_update_reg64 rR11
va_sM
(va_update_reg64 rR10
va_sM
(va_update_reg64 rR9
va_sM
(va_update_reg64 rR8
va_sM
(va_update_reg64 rRsp
va_sM
(va_update_reg64 rRbp
va_sM
(va_update_reg64 rRdi
va_sM
(va_update_reg64 rRsi
va_sM
(va_update_reg64 rRdx
va_sM
(va_update_reg64 rRcx
va_sM
(va_update_reg64 rRbx
va_sM
(va_update_reg64 rRax
va_sM
(va_update_ok va_sM
(va_update_mem
va_sM
va_s0)))
)))))))))))))))))))) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.Memory.nat64",
"Vale.X64.Decls.va_fuel",
"Prims.l_and",
"Vale.Curve25519.X64.FastHybrid.va_req_Fmul1_stdcall",
"Vale.X64.Decls.va_ensure_total",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Vale.Curve25519.Fast_defs.prime",
"Vale.X64.Decls.va_mul_nat",
"Vale.X64.Decls.modifies_buffer",
"Vale.X64.Decls.va_get_mem",
"Prims.l_imp",
"Vale.Def.Types_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRbp",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR15",
"Prims.l_not",
"Prims.nat",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.buffer64_read",
"Vale.X64.Decls.va_int_range",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_stackTaint",
"Vale.X64.Decls.va_update_stack",
"Vale.X64.Decls.va_update_mem_layout",
"Vale.X64.Decls.va_update_mem_heaplet",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_reg64",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_mem",
"Prims.prop"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b))
//--
//-- Fadd_stdcall
val va_code_Fadd_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fadd_stdcall : win:bool -> Tot va_pbool
let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fadd_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fadd_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fadd_stdcall win)) =
(va_QProc (va_code_Fadd_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fadd_stdcall win dst_b inA_b inB_b))
//--
//-- Fsub
val va_code_Fsub : va_dummy:unit -> Tot va_code
val va_codegen_success_Fsub : va_dummy:unit -> Tot va_pbool
let va_req_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fsub : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9
(va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem
va_x_mem va_s0))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fsub : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fsub ())) =
(va_QProc (va_code_Fsub ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) (va_wp_Fsub dst_b inA_b inB_b) (va_wpProof_Fsub dst_b inA_b inB_b))
//--
//-- Fsub_stdcall
val va_code_Fsub_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fsub_stdcall : win:bool -> Tot va_pbool
let va_req_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fsub_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fsub_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fsub_stdcall win)) =
(va_QProc (va_code_Fsub_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fsub_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fsub_stdcall win dst_b inA_b inB_b))
//--
//-- Fmul1
val va_code_Fmul1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fmul1 : va_dummy:unit -> Tot va_pbool
let va_req_Fmul1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) :
prop =
(va_require_total va_b0 (va_code_Fmul1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ va_get_reg64
rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b
inA_b \/ dst_b == inA_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64
rRdi va_s0) dst_b 4 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
va_get_reg64 rRdx va_s0 < 131072))
let va_ens_Fmul1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fmul1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok
va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem
va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem
va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem
va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem
va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a
(va_get_reg64 rRdx va_s0) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem va_s0) (va_get_mem va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM
(va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
val va_lemma_Fmul1 : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fmul1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ va_get_reg64
rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b
inA_b \/ dst_b == inA_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64
rRdi va_s0) dst_b 4 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
va_get_reg64 rRdx va_s0 < 131072)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a
(va_get_reg64 rRdx va_s0) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem va_s0) (va_get_mem va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM
(va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))
[@ va_qattr]
let va_wp_Fmul1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ va_get_reg64
rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b
inA_b \/ dst_b == inA_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64
rRdi va_s0) dst_b 4 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
va_get_reg64 rRdx va_s0 < 131072) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR13
va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10
(va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64
rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))))) in va_get_ok
va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem
va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem
va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem
va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem
va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a
(va_get_reg64 rRdx va_s0) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k va_sM (())))
val va_wpProof_Fmul1 : dst_b:buffer64 -> inA_b:buffer64 -> inB:nat64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fmul1 dst_b inA_b inB va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fmul1 ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fmul1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) : (va_quickCode unit
(va_code_Fmul1 ())) =
(va_QProc (va_code_Fmul1 ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0;
va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
(va_wp_Fmul1 dst_b inA_b inB) (va_wpProof_Fmul1 dst_b inA_b inB))
//--
//-- Fmul1_stdcall
val va_code_Fmul1_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fmul1_stdcall : win:bool -> Tot va_pbool
let va_req_Fmul1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) : prop =
(va_require_total va_b0 (va_code_Fmul1_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret /\ inB_in < 131072))
let va_ens_Fmul1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64) | false | true | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_ens_Fmul1_stdcall
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | [] | Vale.Curve25519.X64.FastHybrid.va_ens_Fmul1_stdcall | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
win: Prims.bool ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_in: Vale.X64.Memory.nat64 ->
va_sM: Vale.X64.Decls.va_state ->
va_fM: Vale.X64.Decls.va_fuel
-> Prims.prop | {
"end_col": 73,
"end_line": 1004,
"start_col": 2,
"start_line": 973
} |
Prims.Tot | val va_wp_Fadd_stdcall
(win: bool)
(dst_b inA_b inB_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_wp_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (()))) | val va_wp_Fadd_stdcall
(win: bool)
(dst_b inA_b inB_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Fadd_stdcall
(win: bool)
(dst_b inA_b inB_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_get_ok va_s0 /\
(let dst_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0)
in
let inA_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0)
in
let inB_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0)
in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
dst_in
dst_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
inA_in
inA_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
inB_in
inB_b
4
(va_get_mem_layout va_s0)
Secret) /\
(forall (va_x_mem: vale_heap) (va_x_rax: nat64) (va_x_rbx: nat64) (va_x_rcx: nat64)
(va_x_rdx: nat64) (va_x_rsi: nat64) (va_x_rdi: nat64) (va_x_rbp: nat64) (va_x_rsp: nat64)
(va_x_r8: nat64) (va_x_r9: nat64) (va_x_r10: nat64) (va_x_r11: nat64) (va_x_r13: nat64)
(va_x_r14: nat64) (va_x_r15: nat64) (va_x_efl: Vale.X64.Flags.t) (va_x_heap0: vale_heap)
(va_x_memLayout: vale_heap_layout) (va_x_stack: vale_stack) (va_x_stackTaint: memtaint).
let va_sM =
va_upd_stackTaint va_x_stackTaint
(va_upd_stack va_x_stack
(va_upd_mem_layout va_x_memLayout
(va_upd_mem_heaplet 0
va_x_heap0
(va_upd_flags va_x_efl
(va_upd_reg64 rR15
va_x_r15
(va_upd_reg64 rR14
va_x_r14
(va_upd_reg64 rR13
va_x_r13
(va_upd_reg64 rR11
va_x_r11
(va_upd_reg64 rR10
va_x_r10
(va_upd_reg64 rR9
va_x_r9
(va_upd_reg64 rR8
va_x_r8
(va_upd_reg64 rRsp
va_x_rsp
(va_upd_reg64 rRbp
va_x_rbp
(va_upd_reg64 rRdi
va_x_rdi
(va_upd_reg64 rRsi
va_x_rsi
(va_upd_reg64 rRdx
va_x_rdx
(va_upd_reg64 rRcx
va_x_rcx
(va_upd_reg64 rRbx
va_x_rbx
(va_upd_reg64 rRax
va_x_rax
(va_upd_mem va_x_mem
va_s0)))))
)))))))))))))))
in
va_get_ok va_sM /\
(let dst_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0)
in
let inA_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0)
in
let inB_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0)
in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let b0 = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let b1 = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let b2 = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let b3 = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in
let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in
let d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in
let d3 = Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in
let a = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let b = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in
let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in
d `op_Modulus` prime == (a + b) `op_Modulus` prime /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\
(win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\
(win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\
(win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\
(win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
(~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\
(~win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\
(~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Stack_i.init_rsp",
"Vale.X64.Decls.va_get_stack",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled",
"Prims.l_or",
"Vale.X64.Decls.buffers_disjoint",
"Vale.X64.Decls.validDstAddrs64",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validSrcAddrs64",
"Vale.X64.Decls.va_int_range",
"Vale.X64.Decls.va_if",
"Vale.Def.Types_s.nat64",
"Vale.X64.Machine_s.rR8",
"Prims.l_not",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRdi",
"Prims.l_Forall",
"Vale.X64.InsBasic.vale_heap",
"Vale.X64.Memory.nat64",
"Vale.X64.Flags.t",
"Vale.Arch.HeapImpl.vale_heap_layout",
"Vale.X64.InsBasic.vale_stack",
"Vale.X64.Memory.memtaint",
"Prims.l_imp",
"Prims.int",
"Prims.op_Modulus",
"Vale.Curve25519.Fast_defs.prime",
"Prims.op_Addition",
"Vale.X64.Decls.modifies_buffer",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRbp",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR15",
"Prims.nat",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.X64.Decls.buffer64_read",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_stackTaint",
"Vale.X64.Decls.va_upd_stack",
"Vale.X64.Decls.va_upd_mem_layout",
"Vale.X64.Decls.va_upd_mem_heaplet",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_reg64",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_upd_mem"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b))
//--
//-- Fadd_stdcall
val va_code_Fadd_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fadd_stdcall : win:bool -> Tot va_pbool
let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fadd_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) | false | true | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Fadd_stdcall
(win: bool)
(dst_b inA_b inB_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.Curve25519.X64.FastHybrid.va_wp_Fadd_stdcall | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
win: Prims.bool ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_b: Vale.X64.Memory.buffer64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 21,
"end_line": 463,
"start_col": 2,
"start_line": 409
} |
Prims.Tot | val va_wp_Fsub_stdcall
(win: bool)
(dst_b inA_b inB_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_wp_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (()))) | val va_wp_Fsub_stdcall
(win: bool)
(dst_b inA_b inB_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Fsub_stdcall
(win: bool)
(dst_b inA_b inB_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_get_ok va_s0 /\
(let dst_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0)
in
let inA_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0)
in
let inB_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0)
in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
dst_in
dst_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
inA_in
inA_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
inB_in
inB_b
4
(va_get_mem_layout va_s0)
Secret) /\
(forall (va_x_mem: vale_heap) (va_x_rax: nat64) (va_x_rbx: nat64) (va_x_rcx: nat64)
(va_x_rdx: nat64) (va_x_rsi: nat64) (va_x_rdi: nat64) (va_x_rbp: nat64) (va_x_rsp: nat64)
(va_x_r8: nat64) (va_x_r9: nat64) (va_x_r10: nat64) (va_x_r11: nat64) (va_x_r13: nat64)
(va_x_r14: nat64) (va_x_r15: nat64) (va_x_efl: Vale.X64.Flags.t) (va_x_heap0: vale_heap)
(va_x_memLayout: vale_heap_layout) (va_x_stack: vale_stack) (va_x_stackTaint: memtaint).
let va_sM =
va_upd_stackTaint va_x_stackTaint
(va_upd_stack va_x_stack
(va_upd_mem_layout va_x_memLayout
(va_upd_mem_heaplet 0
va_x_heap0
(va_upd_flags va_x_efl
(va_upd_reg64 rR15
va_x_r15
(va_upd_reg64 rR14
va_x_r14
(va_upd_reg64 rR13
va_x_r13
(va_upd_reg64 rR11
va_x_r11
(va_upd_reg64 rR10
va_x_r10
(va_upd_reg64 rR9
va_x_r9
(va_upd_reg64 rR8
va_x_r8
(va_upd_reg64 rRsp
va_x_rsp
(va_upd_reg64 rRbp
va_x_rbp
(va_upd_reg64 rRdi
va_x_rdi
(va_upd_reg64 rRsi
va_x_rsi
(va_upd_reg64 rRdx
va_x_rdx
(va_upd_reg64 rRcx
va_x_rcx
(va_upd_reg64 rRbx
va_x_rbx
(va_upd_reg64 rRax
va_x_rax
(va_upd_mem va_x_mem
va_s0)))))
)))))))))))))))
in
va_get_ok va_sM /\
(let dst_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0)
in
let inA_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0)
in
let inB_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0)
in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let b0 = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let b1 = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let b2 = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let b3 = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in
let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in
let d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in
let d3 = Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in
let a = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let b = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in
let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in
d `op_Modulus` prime == (a - b) `op_Modulus` prime /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\
(win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\
(win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\
(win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\
(win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
(~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\
(~win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\
(~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Stack_i.init_rsp",
"Vale.X64.Decls.va_get_stack",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled",
"Prims.l_or",
"Vale.X64.Decls.buffers_disjoint",
"Vale.X64.Decls.validDstAddrs64",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validSrcAddrs64",
"Vale.X64.Decls.va_int_range",
"Vale.X64.Decls.va_if",
"Vale.Def.Types_s.nat64",
"Vale.X64.Machine_s.rR8",
"Prims.l_not",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRdi",
"Prims.l_Forall",
"Vale.X64.InsBasic.vale_heap",
"Vale.X64.Memory.nat64",
"Vale.X64.Flags.t",
"Vale.Arch.HeapImpl.vale_heap_layout",
"Vale.X64.InsBasic.vale_stack",
"Vale.X64.Memory.memtaint",
"Prims.l_imp",
"Prims.int",
"Prims.op_Modulus",
"Vale.Curve25519.Fast_defs.prime",
"Prims.op_Subtraction",
"Vale.X64.Decls.modifies_buffer",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRbp",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR15",
"Prims.nat",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.X64.Decls.buffer64_read",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_stackTaint",
"Vale.X64.Decls.va_upd_stack",
"Vale.X64.Decls.va_upd_mem_layout",
"Vale.X64.Decls.va_upd_mem_heaplet",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_reg64",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_upd_mem"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b))
//--
//-- Fadd_stdcall
val va_code_Fadd_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fadd_stdcall : win:bool -> Tot va_pbool
let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fadd_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fadd_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fadd_stdcall win)) =
(va_QProc (va_code_Fadd_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fadd_stdcall win dst_b inA_b inB_b))
//--
//-- Fsub
val va_code_Fsub : va_dummy:unit -> Tot va_code
val va_codegen_success_Fsub : va_dummy:unit -> Tot va_pbool
let va_req_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fsub : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9
(va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem
va_x_mem va_s0))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fsub : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fsub ())) =
(va_QProc (va_code_Fsub ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) (va_wp_Fsub dst_b inA_b inB_b) (va_wpProof_Fsub dst_b inA_b inB_b))
//--
//-- Fsub_stdcall
val va_code_Fsub_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fsub_stdcall : win:bool -> Tot va_pbool
let va_req_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fsub_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) | false | true | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Fsub_stdcall
(win: bool)
(dst_b inA_b inB_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.Curve25519.X64.FastHybrid.va_wp_Fsub_stdcall | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
win: Prims.bool ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_b: Vale.X64.Memory.buffer64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 21,
"end_line": 808,
"start_col": 2,
"start_line": 754
} |
Prims.Tot | val va_wp_Fmul1_stdcall
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastHybrid_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"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
}
] | false | let va_wp_Fmul1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in =
va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ inB_in < 131072) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let a0 =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_four
d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a inB_in `op_Modulus` prime /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\
(win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp
va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13
va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64
rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==>
va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM ==
va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==> va_k va_sM (()))) | val va_wp_Fmul1_stdcall
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Fmul1_stdcall
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_get_ok va_s0 /\
(let dst_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0)
in
let inA_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0)
in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\
inB_in = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
dst_in
dst_b
4
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
inA_in
inA_b
4
(va_get_mem_layout va_s0)
Secret /\ inB_in < 131072) /\
(forall (va_x_mem: vale_heap) (va_x_rax: nat64) (va_x_rbx: nat64) (va_x_rcx: nat64)
(va_x_rdx: nat64) (va_x_rsi: nat64) (va_x_rdi: nat64) (va_x_rbp: nat64) (va_x_rsp: nat64)
(va_x_r8: nat64) (va_x_r9: nat64) (va_x_r10: nat64) (va_x_r11: nat64) (va_x_r13: nat64)
(va_x_r14: nat64) (va_x_r15: nat64) (va_x_efl: Vale.X64.Flags.t) (va_x_heap0: vale_heap)
(va_x_memLayout: vale_heap_layout) (va_x_stack: vale_stack) (va_x_stackTaint: memtaint).
let va_sM =
va_upd_stackTaint va_x_stackTaint
(va_upd_stack va_x_stack
(va_upd_mem_layout va_x_memLayout
(va_upd_mem_heaplet 0
va_x_heap0
(va_upd_flags va_x_efl
(va_upd_reg64 rR15
va_x_r15
(va_upd_reg64 rR14
va_x_r14
(va_upd_reg64 rR13
va_x_r13
(va_upd_reg64 rR11
va_x_r11
(va_upd_reg64 rR10
va_x_r10
(va_upd_reg64 rR9
va_x_r9
(va_upd_reg64 rR8
va_x_r8
(va_upd_reg64 rRsp
va_x_rsp
(va_upd_reg64 rRbp
va_x_rbp
(va_upd_reg64 rRdi
va_x_rdi
(va_upd_reg64 rRsi
va_x_rsi
(va_upd_reg64 rRdx
va_x_rdx
(va_upd_reg64 rRcx
va_x_rcx
(va_upd_reg64 rRbx
va_x_rbx
(va_upd_reg64 rRax
va_x_rax
(va_upd_mem va_x_mem
va_s0)))))
)))))))))))))))
in
va_get_ok va_sM /\
(let dst_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0)
in
let inA_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0)
in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let a3 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in
let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in
let d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in
let d3 = Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in
let a = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in
d `op_Modulus` prime == (va_mul_nat a inB_in) `op_Modulus` prime /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\
(win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\
(win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\
(win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\
(win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
(win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
(~win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\
(~win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\
(~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\
(~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.Curve25519.X64.FastHybrid.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastHybrid.fsti"
} | [
"total"
] | [
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.Memory.nat64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Stack_i.init_rsp",
"Vale.X64.Decls.va_get_stack",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled",
"Prims.l_or",
"Vale.X64.Decls.buffers_disjoint",
"Prims.op_Equality",
"Vale.X64.Decls.va_if",
"Vale.Def.Types_s.nat64",
"Vale.X64.Machine_s.rR8",
"Prims.l_not",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Decls.validDstAddrs64",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validSrcAddrs64",
"Prims.op_LessThan",
"Vale.X64.Decls.va_int_range",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRdi",
"Prims.l_Forall",
"Vale.X64.InsBasic.vale_heap",
"Vale.X64.Flags.t",
"Vale.Arch.HeapImpl.vale_heap_layout",
"Vale.X64.InsBasic.vale_stack",
"Vale.X64.Memory.memtaint",
"Prims.l_imp",
"Prims.int",
"Prims.op_Modulus",
"Vale.Curve25519.Fast_defs.prime",
"Vale.X64.Decls.va_mul_nat",
"Vale.X64.Decls.modifies_buffer",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRbp",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR15",
"Prims.nat",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.X64.Decls.buffer64_read",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_stackTaint",
"Vale.X64.Decls.va_upd_stack",
"Vale.X64.Decls.va_upd_mem_layout",
"Vale.X64.Decls.va_upd_mem_heaplet",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_reg64",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_upd_mem"
] | [] | module Vale.Curve25519.X64.FastHybrid
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Carry_wide
val va_code_Carry_wide : offset:nat -> Tot va_code
val va_codegen_success_Carry_wide : offset:nat -> Tot va_pbool
val va_lemma_Carry_wide : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Carry_wide offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let
(a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled /\ bmi2_enabled /\
(offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b)
/\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b
(4 + offset) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in let d0 =
Vale.X64.Decls.buffer64_read dst_b (0 + offset) (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b (1 + offset) (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b (2 + offset) (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b (3 + offset) (va_get_mem_heaplet 0 va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == a `op_Modulus` prime
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b
(4 + offset) (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
[@ va_qattr]
let va_wp_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a4:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a5:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a6:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a7:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 in adx_enabled
/\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b
\/ inA_b == dst_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64
rRdi va_s0) dst_b (4 + offset) (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_rax:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64)
(va_x_r10:nat64) (va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64
rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0))))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (0 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (1 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a4:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a5:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (5 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a6:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (6 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_s0) in
let (a7:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (7 + offset `op_Multiply`
2) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_eight a0
a1 a2 a3 a4 a5 a6 a7 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset)
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2 + offset)
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b (3 + offset)
(va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d
`op_Modulus` prime == a `op_Modulus` prime /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (4 + offset) (va_get_mem_layout
va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b (va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) (0 + offset) (4 + offset - 1)) ==> va_k va_sM (())))
val va_wpProof_Carry_wide : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Carry_wide offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Carry_wide offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64
rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Carry_wide (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Carry_wide offset)) =
(va_QProc (va_code_Carry_wide offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13;
va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Carry_wide offset
dst_b inA_b) (va_wpProof_Carry_wide offset dst_b inA_b))
//--
//-- Fadd
val va_code_Fadd : va_dummy:unit -> Tot va_code
val va_codegen_success_Fadd : va_dummy:unit -> Tot va_pbool
let va_req_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
val va_lemma_Fadd : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))
[@ va_qattr]
let va_wp_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_layout
va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx
(va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))) in
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a + b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fadd : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fadd ())) =
(va_QProc (va_code_Fadd ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd dst_b inA_b inB_b) (va_wpProof_Fadd dst_b
inA_b inB_b))
//--
//-- Fadd_stdcall
val va_code_Fadd_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fadd_stdcall : win:bool -> Tot va_pbool
let va_req_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fadd_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fadd_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fadd_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fadd_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a + b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fadd_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fadd_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fadd_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fadd_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fadd_stdcall win)) =
(va_QProc (va_code_Fadd_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fadd_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fadd_stdcall win dst_b inA_b inB_b))
//--
//-- Fsub
val va_code_Fsub : va_dummy:unit -> Tot va_code
val va_codegen_success_Fsub : va_dummy:unit -> Tot va_pbool
let va_req_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
: prop =
(va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub va_b0 va_s0 dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\
va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
val va_lemma_Fsub : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let
(b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let
(b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let
(b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\ bmi2_enabled /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in
let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in
let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in
let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0
va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))
[@ va_qattr]
let va_wp_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 0
(va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 1
(va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 2
(va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inB_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let (b:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in adx_enabled /\
bmi2_enabled /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdi va_s0) dst_b 4
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) (va_get_reg64 rRdx va_s0) inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9
(va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem
va_x_mem va_s0))))))))) in va_get_ok va_sM /\ (let (a0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let (b0:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let (b1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let (b2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let (b3:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let (b:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four b0 b1 b2 b3 in let d0 = Vale.X64.Decls.buffer64_read dst_b
0 (va_get_mem va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let
d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == (a - b) `op_Modulus`
prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k
va_sM (())))
val va_wpProof_Fsub : dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64
rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) : (va_quickCode unit
(va_code_Fsub ())) =
(va_QProc (va_code_Fsub ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRcx; va_Mod_reg64
rRax; va_Mod_mem]) (va_wp_Fsub dst_b inA_b inB_b) (va_wpProof_Fsub dst_b inA_b inB_b))
//--
//-- Fsub_stdcall
val va_code_Fsub_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fsub_stdcall : win:bool -> Tot va_pbool
let va_req_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) : prop =
(va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret))
let va_ens_Fsub_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_b:buffer64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fsub_stdcall va_b0 va_s0 win dst_b inA_b inB_b /\ va_ensure_total va_b0 va_s0 va_sM va_fM
/\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (inB_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else
va_get_reg64 rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fsub_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fsub_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\
bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack va_sM (va_update_mem_layout
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rR15 va_sM
(va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM
(va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in let (inB_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ dst_b == inA_b) /\
(Vale.X64.Decls.buffers_disjoint dst_b inB_b \/ dst_b == inB_b) /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inB_in inB_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rsi:nat64) (va_x_rdi:nat64)
(va_x_rbp:nat64) (va_x_rsp:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_memLayout:vale_heap_layout) (va_x_stack:vale_stack)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_stack
va_x_stack (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_flags
va_x_efl (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (inB_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64
rRdx va_s0) in let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let b0 =
Vale.X64.Decls.buffer64_read inB_b 0 (va_get_mem va_s0) in let b1 =
Vale.X64.Decls.buffer64_read inB_b 1 (va_get_mem va_s0) in let b2 =
Vale.X64.Decls.buffer64_read inB_b 2 (va_get_mem va_s0) in let b3 =
Vale.X64.Decls.buffer64_read inB_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let b = Vale.Curve25519.Fast_defs.pow2_four
b0 b1 b2 b3 in let d = Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime
== (a - b) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0)
(va_get_mem va_sM) /\ (win ==> va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==>
va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM ==
va_get_reg64 rRdi va_s0) /\ (win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\
(win ==> va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13
va_sM == va_get_reg64 rR13 va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14
va_s0) /\ (win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (~win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\
(~win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15
va_sM == va_get_reg64 rR15 va_s0) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (())))
val va_wpProof_Fsub_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> inB_b:buffer64 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fsub_stdcall win dst_b inA_b inB_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fsub_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsp; va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fsub_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_b:buffer64) :
(va_quickCode unit (va_code_Fsub_stdcall win)) =
(va_QProc (va_code_Fsub_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_layout;
va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsp;
va_Mod_reg64 rRbp; va_Mod_reg64 rRdi; va_Mod_reg64 rRsi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Fsub_stdcall win dst_b inA_b inB_b)
(va_wpProof_Fsub_stdcall win dst_b inA_b inB_b))
//--
//-- Fmul1
val va_code_Fmul1 : va_dummy:unit -> Tot va_code
val va_codegen_success_Fmul1 : va_dummy:unit -> Tot va_pbool
let va_req_Fmul1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) :
prop =
(va_require_total va_b0 (va_code_Fmul1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ va_get_reg64
rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b
inA_b \/ dst_b == inA_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64
rRdi va_s0) dst_b 4 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
va_get_reg64 rRdx va_s0 < 131072))
let va_ens_Fmul1 (va_b0:va_code) (va_s0:va_state) (dst_b:buffer64) (inA_b:buffer64) (inB:nat64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fmul1 va_b0 va_s0 dst_b inA_b inB /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok
va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem
va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem
va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem
va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem
va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a
(va_get_reg64 rRdx va_s0) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem va_s0) (va_get_mem va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM
(va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))
val va_lemma_Fmul1 : va_b0:va_code -> va_s0:va_state -> dst_b:buffer64 -> inA_b:buffer64 ->
inB:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fmul1 ()) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let
(a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let
(a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ va_get_reg64
rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b
inA_b \/ dst_b == inA_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64
rRdi va_s0) dst_b 4 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
va_get_reg64 rRdx va_s0 < 131072)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in
let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in
let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in
let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in
let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a
(va_get_reg64 rRdx va_s0) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem va_s0) (va_get_mem va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM
(va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM
(va_update_reg64 rR9 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))
[@ va_qattr]
let va_wp_Fmul1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0
(va_get_mem va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\ va_get_reg64
rRdx va_s0 == inB /\ (adx_enabled /\ bmi2_enabled) /\ (Vale.X64.Decls.buffers_disjoint dst_b
inA_b \/ dst_b == inA_b) /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (va_get_reg64
rRdi va_s0) dst_b 4 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_get_reg64 rRsi va_s0) inA_b 4 (va_get_mem_layout va_s0) Secret /\
va_get_reg64 rRdx va_s0 < 131072) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_rbx:nat64) (va_x_r13:nat64) (va_x_heap0:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_mem_layout va_x_memLayout (va_upd_mem_heaplet 0 va_x_heap0 (va_upd_reg64 rR13
va_x_r13 (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10
(va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64
rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))))))))) in va_get_ok
va_sM /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem
va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem
va_s0) in let (a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem
va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem
va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let d =
Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a
(va_get_reg64 rRdx va_s0) `op_Modulus` prime /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem va_s0) (va_get_mem va_sM)) ==> va_k va_sM (())))
val va_wpProof_Fmul1 : dst_b:buffer64 -> inA_b:buffer64 -> inB:nat64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fmul1 dst_b inA_b inB va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fmul1 ()) ([va_Mod_flags;
va_Mod_mem_layout; va_Mod_mem_heaplet 0; va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fmul1 (dst_b:buffer64) (inA_b:buffer64) (inB:nat64) : (va_quickCode unit
(va_code_Fmul1 ())) =
(va_QProc (va_code_Fmul1 ()) ([va_Mod_flags; va_Mod_mem_layout; va_Mod_mem_heaplet 0;
va_Mod_reg64 rR13; va_Mod_reg64 rRbx; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem])
(va_wp_Fmul1 dst_b inA_b inB) (va_wpProof_Fmul1 dst_b inA_b inB))
//--
//-- Fmul1_stdcall
val va_code_Fmul1_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fmul1_stdcall : win:bool -> Tot va_pbool
let va_req_Fmul1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) : prop =
(va_require_total va_b0 (va_code_Fmul1_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret /\ inB_in < 131072))
let va_ens_Fmul1_stdcall (va_b0:va_code) (va_s0:va_state) (win:bool) (dst_b:buffer64)
(inA_b:buffer64) (inB_in:nat64) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Fmul1_stdcall va_b0 va_s0 win dst_b inA_b inB_in /\ va_ensure_total va_b0 va_s0 va_sM
va_fM /\ va_get_ok va_sM /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_four
d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a inB_in `op_Modulus` prime /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\
(win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp
va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13
va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64
rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==>
va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM ==
va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint
va_sM (va_update_stack va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM
(va_update_flags va_sM (va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64
rR13 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))))))))))))))))
val va_lemma_Fmul1_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64 -> inB_in:nat64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fmul1_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
(Vale.X64.Decls.buffers_disjoint dst_b inA_b \/ inA_b == dst_b) /\ inB_in = (if win then
va_get_reg64 rR8 va_s0 else va_get_reg64 rRdx va_s0) /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem va_s0) dst_in dst_b 4 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0) inA_in inA_b 4 (va_get_mem_layout va_s0)
Secret /\ inB_in < 131072)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let a0 = Vale.X64.Decls.buffer64_read
inA_b 0 (va_get_mem va_s0) in let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem va_s0)
in let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem va_sM) in let a =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in let d = Vale.Curve25519.Fast_defs.pow2_four
d0 d1 d2 d3 in d `op_Modulus` prime == va_mul_nat a inB_in `op_Modulus` prime /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem va_s0) (va_get_mem va_sM) /\ (win ==>
va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0) /\ (win ==> va_get_reg64 rRbp va_sM ==
va_get_reg64 rRbp va_s0) /\ (win ==> va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0) /\
(win ==> va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0) /\ (win ==> va_get_reg64 rRsp
va_sM == va_get_reg64 rRsp va_s0) /\ (win ==> va_get_reg64 rR13 va_sM == va_get_reg64 rR13
va_s0) /\ (win ==> va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0) /\ (win ==> va_get_reg64
rR15 va_sM == va_get_reg64 rR15 va_s0) /\ (~win ==> va_get_reg64 rRbx va_sM == va_get_reg64
rRbx va_s0) /\ (~win ==> va_get_reg64 rRbp va_sM == va_get_reg64 rRbp va_s0) /\ (~win ==>
va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0) /\ (~win ==> va_get_reg64 rR14 va_sM ==
va_get_reg64 rR14 va_s0) /\ (~win ==> va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0) /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint
va_sM (va_update_stack va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 0 va_sM
(va_update_flags va_sM (va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64
rR13 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsp va_sM (va_update_reg64 rRbp va_sM
(va_update_reg64 rRdi va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fmul1_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (inB_in:nat64) | false | true | Vale.Curve25519.X64.FastHybrid.fsti | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Fmul1_stdcall
(win: bool)
(dst_b inA_b: buffer64)
(inB_in: nat64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.Curve25519.X64.FastHybrid.va_wp_Fmul1_stdcall | {
"file_name": "obj/Vale.Curve25519.X64.FastHybrid.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
win: Prims.bool ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
inB_in: Vale.X64.Memory.nat64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 77,
"end_line": 1099,
"start_col": 2,
"start_line": 1054
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Point",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.PrecompTable",
"short_module": "SPTK"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Hacl.Impl.K256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Point",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation.Definitions",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Hacl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.K256",
"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
}
] | false | let pow_point (k:nat) (p:S.aff_point) =
LE.pow S.mk_k256_comm_monoid p k | let pow_point (k: nat) (p: S.aff_point) = | false | null | false | LE.pow S.mk_k256_comm_monoid p k | {
"checked_file": "Hacl.K256.PrecompTable.fsti.checked",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable.fsti.checked",
"Hacl.Impl.K256.Point.fsti.checked",
"Hacl.Impl.K256.Group.fst.checked",
"Hacl.Impl.Exponentiation.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.K256.PrecompTable.fsti"
} | [
"total"
] | [
"Prims.nat",
"Spec.K256.PointOps.aff_point",
"Lib.Exponentiation.Definition.pow",
"Spec.K256.mk_k256_comm_monoid"
] | [] | module Hacl.K256.PrecompTable
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module LE = Lib.Exponentiation.Definition
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation.Definitions
module SPT = Hacl.Spec.PrecompBaseTable
module S = Spec.K256
open Hacl.Impl.K256.Point
include Hacl.Impl.K256.Group
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val proj_point_to_list: p:S.proj_point
-> x:list uint64{FStar.List.Tot.length x = 15 /\
mk_to_k256_comm_monoid.BE.linv (Seq.seq_of_list x)}
val lemma_refl: x:S.proj_point ->
Lemma (S.mk_k256_concrete_ops.SE.to.SE.refl x ==
mk_to_k256_comm_monoid.BE.refl (Seq.seq_of_list (proj_point_to_list x)))
inline_for_extraction noextract
let mk_k256_precomp_base_table: SPT.mk_precomp_base_table S.proj_point U64 15ul 0ul = {
SPT.concr_ops = S.mk_k256_concrete_ops;
SPT.to_cm = mk_to_k256_comm_monoid;
SPT.to_list = proj_point_to_list;
SPT.lemma_refl = lemma_refl;
}
inline_for_extraction noextract | false | true | Hacl.K256.PrecompTable.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pow_point : k: Prims.nat -> p: Spec.K256.PointOps.aff_point -> Spec.K256.PointOps.aff_point | [] | Hacl.K256.PrecompTable.pow_point | {
"file_name": "code/k256/Hacl.K256.PrecompTable.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | k: Prims.nat -> p: Spec.K256.PointOps.aff_point -> Spec.K256.PointOps.aff_point | {
"end_col": 34,
"end_line": 44,
"start_col": 2,
"start_line": 44
} |
|
Prims.Tot | val g_aff:S.aff_point | [
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Point",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.PrecompTable",
"short_module": "SPTK"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Hacl.Impl.K256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Point",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation.Definitions",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Hacl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.K256",
"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
}
] | false | let g_aff : S.aff_point = S.to_aff_point S.g | val g_aff:S.aff_point
let g_aff:S.aff_point = | false | null | false | S.to_aff_point S.g | {
"checked_file": "Hacl.K256.PrecompTable.fsti.checked",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable.fsti.checked",
"Hacl.Impl.K256.Point.fsti.checked",
"Hacl.Impl.K256.Group.fst.checked",
"Hacl.Impl.Exponentiation.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.K256.PrecompTable.fsti"
} | [
"total"
] | [
"Spec.K256.PointOps.to_aff_point",
"Spec.K256.PointOps.g"
] | [] | module Hacl.K256.PrecompTable
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module LE = Lib.Exponentiation.Definition
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation.Definitions
module SPT = Hacl.Spec.PrecompBaseTable
module S = Spec.K256
open Hacl.Impl.K256.Point
include Hacl.Impl.K256.Group
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val proj_point_to_list: p:S.proj_point
-> x:list uint64{FStar.List.Tot.length x = 15 /\
mk_to_k256_comm_monoid.BE.linv (Seq.seq_of_list x)}
val lemma_refl: x:S.proj_point ->
Lemma (S.mk_k256_concrete_ops.SE.to.SE.refl x ==
mk_to_k256_comm_monoid.BE.refl (Seq.seq_of_list (proj_point_to_list x)))
inline_for_extraction noextract
let mk_k256_precomp_base_table: SPT.mk_precomp_base_table S.proj_point U64 15ul 0ul = {
SPT.concr_ops = S.mk_k256_concrete_ops;
SPT.to_cm = mk_to_k256_comm_monoid;
SPT.to_list = proj_point_to_list;
SPT.lemma_refl = lemma_refl;
}
inline_for_extraction noextract
let pow_point (k:nat) (p:S.aff_point) =
LE.pow S.mk_k256_comm_monoid p k
//---------------- | false | true | Hacl.K256.PrecompTable.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val g_aff:S.aff_point | [] | Hacl.K256.PrecompTable.g_aff | {
"file_name": "code/k256/Hacl.K256.PrecompTable.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Spec.K256.PointOps.aff_point | {
"end_col": 44,
"end_line": 49,
"start_col": 26,
"start_line": 49
} |
Prims.Tot | val g_pow2_64:S.aff_point | [
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Point",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.PrecompTable",
"short_module": "SPTK"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Hacl.Impl.K256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Point",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation.Definitions",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Hacl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.K256",
"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
}
] | false | let g_pow2_64 : S.aff_point = pow_point (pow2 64) g_aff | val g_pow2_64:S.aff_point
let g_pow2_64:S.aff_point = | false | null | false | pow_point (pow2 64) g_aff | {
"checked_file": "Hacl.K256.PrecompTable.fsti.checked",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable.fsti.checked",
"Hacl.Impl.K256.Point.fsti.checked",
"Hacl.Impl.K256.Group.fst.checked",
"Hacl.Impl.Exponentiation.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.K256.PrecompTable.fsti"
} | [
"total"
] | [
"Hacl.K256.PrecompTable.pow_point",
"Prims.pow2",
"Hacl.K256.PrecompTable.g_aff"
] | [] | module Hacl.K256.PrecompTable
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module LE = Lib.Exponentiation.Definition
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation.Definitions
module SPT = Hacl.Spec.PrecompBaseTable
module S = Spec.K256
open Hacl.Impl.K256.Point
include Hacl.Impl.K256.Group
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val proj_point_to_list: p:S.proj_point
-> x:list uint64{FStar.List.Tot.length x = 15 /\
mk_to_k256_comm_monoid.BE.linv (Seq.seq_of_list x)}
val lemma_refl: x:S.proj_point ->
Lemma (S.mk_k256_concrete_ops.SE.to.SE.refl x ==
mk_to_k256_comm_monoid.BE.refl (Seq.seq_of_list (proj_point_to_list x)))
inline_for_extraction noextract
let mk_k256_precomp_base_table: SPT.mk_precomp_base_table S.proj_point U64 15ul 0ul = {
SPT.concr_ops = S.mk_k256_concrete_ops;
SPT.to_cm = mk_to_k256_comm_monoid;
SPT.to_list = proj_point_to_list;
SPT.lemma_refl = lemma_refl;
}
inline_for_extraction noextract
let pow_point (k:nat) (p:S.aff_point) =
LE.pow S.mk_k256_comm_monoid p k
//----------------
noextract
let g_aff : S.aff_point = S.to_aff_point S.g
// [pow2 64]G | false | true | Hacl.K256.PrecompTable.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val g_pow2_64:S.aff_point | [] | Hacl.K256.PrecompTable.g_pow2_64 | {
"file_name": "code/k256/Hacl.K256.PrecompTable.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Spec.K256.PointOps.aff_point | {
"end_col": 55,
"end_line": 53,
"start_col": 30,
"start_line": 53
} |
Prims.Tot | val g_pow2_128:S.aff_point | [
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Point",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.PrecompTable",
"short_module": "SPTK"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Hacl.Impl.K256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Point",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation.Definitions",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Hacl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.K256",
"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
}
] | false | let g_pow2_128 : S.aff_point = pow_point (pow2 128) g_aff | val g_pow2_128:S.aff_point
let g_pow2_128:S.aff_point = | false | null | false | pow_point (pow2 128) g_aff | {
"checked_file": "Hacl.K256.PrecompTable.fsti.checked",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable.fsti.checked",
"Hacl.Impl.K256.Point.fsti.checked",
"Hacl.Impl.K256.Group.fst.checked",
"Hacl.Impl.Exponentiation.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.K256.PrecompTable.fsti"
} | [
"total"
] | [
"Hacl.K256.PrecompTable.pow_point",
"Prims.pow2",
"Hacl.K256.PrecompTable.g_aff"
] | [] | module Hacl.K256.PrecompTable
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module LE = Lib.Exponentiation.Definition
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation.Definitions
module SPT = Hacl.Spec.PrecompBaseTable
module S = Spec.K256
open Hacl.Impl.K256.Point
include Hacl.Impl.K256.Group
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val proj_point_to_list: p:S.proj_point
-> x:list uint64{FStar.List.Tot.length x = 15 /\
mk_to_k256_comm_monoid.BE.linv (Seq.seq_of_list x)}
val lemma_refl: x:S.proj_point ->
Lemma (S.mk_k256_concrete_ops.SE.to.SE.refl x ==
mk_to_k256_comm_monoid.BE.refl (Seq.seq_of_list (proj_point_to_list x)))
inline_for_extraction noextract
let mk_k256_precomp_base_table: SPT.mk_precomp_base_table S.proj_point U64 15ul 0ul = {
SPT.concr_ops = S.mk_k256_concrete_ops;
SPT.to_cm = mk_to_k256_comm_monoid;
SPT.to_list = proj_point_to_list;
SPT.lemma_refl = lemma_refl;
}
inline_for_extraction noextract
let pow_point (k:nat) (p:S.aff_point) =
LE.pow S.mk_k256_comm_monoid p k
//----------------
noextract
let g_aff : S.aff_point = S.to_aff_point S.g
// [pow2 64]G
noextract
let g_pow2_64 : S.aff_point = pow_point (pow2 64) g_aff
// [pow2 128]G | false | true | Hacl.K256.PrecompTable.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val g_pow2_128:S.aff_point | [] | Hacl.K256.PrecompTable.g_pow2_128 | {
"file_name": "code/k256/Hacl.K256.PrecompTable.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Spec.K256.PointOps.aff_point | {
"end_col": 57,
"end_line": 57,
"start_col": 31,
"start_line": 57
} |
Prims.Tot | val g_pow2_192:S.aff_point | [
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Point",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.PrecompTable",
"short_module": "SPTK"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Hacl.Impl.K256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Point",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation.Definitions",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Hacl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.K256",
"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
}
] | false | let g_pow2_192 : S.aff_point = pow_point (pow2 192) g_aff | val g_pow2_192:S.aff_point
let g_pow2_192:S.aff_point = | false | null | false | pow_point (pow2 192) g_aff | {
"checked_file": "Hacl.K256.PrecompTable.fsti.checked",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable.fsti.checked",
"Hacl.Impl.K256.Point.fsti.checked",
"Hacl.Impl.K256.Group.fst.checked",
"Hacl.Impl.Exponentiation.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.K256.PrecompTable.fsti"
} | [
"total"
] | [
"Hacl.K256.PrecompTable.pow_point",
"Prims.pow2",
"Hacl.K256.PrecompTable.g_aff"
] | [] | module Hacl.K256.PrecompTable
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module LE = Lib.Exponentiation.Definition
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation.Definitions
module SPT = Hacl.Spec.PrecompBaseTable
module S = Spec.K256
open Hacl.Impl.K256.Point
include Hacl.Impl.K256.Group
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val proj_point_to_list: p:S.proj_point
-> x:list uint64{FStar.List.Tot.length x = 15 /\
mk_to_k256_comm_monoid.BE.linv (Seq.seq_of_list x)}
val lemma_refl: x:S.proj_point ->
Lemma (S.mk_k256_concrete_ops.SE.to.SE.refl x ==
mk_to_k256_comm_monoid.BE.refl (Seq.seq_of_list (proj_point_to_list x)))
inline_for_extraction noextract
let mk_k256_precomp_base_table: SPT.mk_precomp_base_table S.proj_point U64 15ul 0ul = {
SPT.concr_ops = S.mk_k256_concrete_ops;
SPT.to_cm = mk_to_k256_comm_monoid;
SPT.to_list = proj_point_to_list;
SPT.lemma_refl = lemma_refl;
}
inline_for_extraction noextract
let pow_point (k:nat) (p:S.aff_point) =
LE.pow S.mk_k256_comm_monoid p k
//----------------
noextract
let g_aff : S.aff_point = S.to_aff_point S.g
// [pow2 64]G
noextract
let g_pow2_64 : S.aff_point = pow_point (pow2 64) g_aff
// [pow2 128]G
noextract
let g_pow2_128 : S.aff_point = pow_point (pow2 128) g_aff
// [pow2 192]G | false | true | Hacl.K256.PrecompTable.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val g_pow2_192:S.aff_point | [] | Hacl.K256.PrecompTable.g_pow2_192 | {
"file_name": "code/k256/Hacl.K256.PrecompTable.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Spec.K256.PointOps.aff_point | {
"end_col": 57,
"end_line": 61,
"start_col": 31,
"start_line": 61
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Point",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.PrecompTable",
"short_module": "SPTK"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Hacl.Impl.K256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Point",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation.Definitions",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Hacl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.K256",
"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
}
] | false | let precomp_table_acc_inv
(p:S.aff_point)
(table_len:nat{table_len * 15 <= max_size_t})
(table:LSeq.lseq uint64 (table_len * 15))
(j:nat{j < table_len})
=
Math.Lemmas.lemma_mult_lt_right 15 j table_len;
Math.Lemmas.lemma_mult_le_right 15 (j + 1) table_len;
let bj = LSeq.sub table (j * 15) 15 in
point_inv_lseq bj /\ S.to_aff_point (point_eval_lseq bj) == pow_point j p | let precomp_table_acc_inv
(p: S.aff_point)
(table_len: nat{table_len * 15 <= max_size_t})
(table: LSeq.lseq uint64 (table_len * 15))
(j: nat{j < table_len})
= | false | null | false | Math.Lemmas.lemma_mult_lt_right 15 j table_len;
Math.Lemmas.lemma_mult_le_right 15 (j + 1) table_len;
let bj = LSeq.sub table (j * 15) 15 in
point_inv_lseq bj /\ S.to_aff_point (point_eval_lseq bj) == pow_point j p | {
"checked_file": "Hacl.K256.PrecompTable.fsti.checked",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable.fsti.checked",
"Hacl.Impl.K256.Point.fsti.checked",
"Hacl.Impl.K256.Group.fst.checked",
"Hacl.Impl.Exponentiation.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.K256.PrecompTable.fsti"
} | [
"total"
] | [
"Spec.K256.PointOps.aff_point",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Prims.op_LessThan",
"Prims.l_and",
"Hacl.Impl.K256.Point.point_inv_lseq",
"Prims.eq2",
"Spec.K256.PointOps.to_aff_point",
"Hacl.Impl.K256.Point.point_eval_lseq",
"Hacl.K256.PrecompTable.pow_point",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Multiply",
"Prims.op_Addition",
"Prims.l_Forall",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub",
"Prims.unit",
"FStar.Math.Lemmas.lemma_mult_le_right",
"FStar.Math.Lemmas.lemma_mult_lt_right",
"Prims.logical"
] | [] | module Hacl.K256.PrecompTable
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module LE = Lib.Exponentiation.Definition
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation.Definitions
module SPT = Hacl.Spec.PrecompBaseTable
module S = Spec.K256
open Hacl.Impl.K256.Point
include Hacl.Impl.K256.Group
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val proj_point_to_list: p:S.proj_point
-> x:list uint64{FStar.List.Tot.length x = 15 /\
mk_to_k256_comm_monoid.BE.linv (Seq.seq_of_list x)}
val lemma_refl: x:S.proj_point ->
Lemma (S.mk_k256_concrete_ops.SE.to.SE.refl x ==
mk_to_k256_comm_monoid.BE.refl (Seq.seq_of_list (proj_point_to_list x)))
inline_for_extraction noextract
let mk_k256_precomp_base_table: SPT.mk_precomp_base_table S.proj_point U64 15ul 0ul = {
SPT.concr_ops = S.mk_k256_concrete_ops;
SPT.to_cm = mk_to_k256_comm_monoid;
SPT.to_list = proj_point_to_list;
SPT.lemma_refl = lemma_refl;
}
inline_for_extraction noextract
let pow_point (k:nat) (p:S.aff_point) =
LE.pow S.mk_k256_comm_monoid p k
//----------------
noextract
let g_aff : S.aff_point = S.to_aff_point S.g
// [pow2 64]G
noextract
let g_pow2_64 : S.aff_point = pow_point (pow2 64) g_aff
// [pow2 128]G
noextract
let g_pow2_128 : S.aff_point = pow_point (pow2 128) g_aff
// [pow2 192]G
noextract
let g_pow2_192 : S.aff_point = pow_point (pow2 192) g_aff
inline_for_extraction noextract
val proj_g_pow2_64_lseq : LSeq.lseq uint64 15
inline_for_extraction noextract
val proj_g_pow2_128_lseq : LSeq.lseq uint64 15
inline_for_extraction noextract
val proj_g_pow2_192_lseq : LSeq.lseq uint64 15
val proj_g_pow2_64_lseq_lemma: unit ->
Lemma (point_inv_lseq proj_g_pow2_64_lseq /\
S.to_aff_point (point_eval_lseq proj_g_pow2_64_lseq) == g_pow2_64)
val proj_g_pow2_128_lseq_lemma: unit ->
Lemma (point_inv_lseq proj_g_pow2_128_lseq /\
S.to_aff_point (point_eval_lseq proj_g_pow2_128_lseq) == g_pow2_128)
val proj_g_pow2_192_lseq_lemma: unit ->
Lemma (point_inv_lseq proj_g_pow2_192_lseq /\
S.to_aff_point (point_eval_lseq proj_g_pow2_192_lseq) == g_pow2_192)
inline_for_extraction
val mk_proj_g_pow2_64: unit -> StackInline (lbuffer uint64 15ul)
(requires fun _ -> True)
(ensures fun h0 b h1 -> live h1 b /\ stack_allocated b h0 h1 proj_g_pow2_64_lseq)
inline_for_extraction
val mk_proj_g_pow2_128: unit -> StackInline (lbuffer uint64 15ul)
(requires fun _ -> True)
(ensures fun h0 b h1 -> live h1 b /\ stack_allocated b h0 h1 proj_g_pow2_128_lseq)
inline_for_extraction
val mk_proj_g_pow2_192: unit -> StackInline (lbuffer uint64 15ul)
(requires fun _ -> True)
(ensures fun h0 b h1 -> live h1 b /\ stack_allocated b h0 h1 proj_g_pow2_192_lseq)
//----------------
unfold
let precomp_table_acc_inv
(p:S.aff_point)
(table_len:nat{table_len * 15 <= max_size_t})
(table:LSeq.lseq uint64 (table_len * 15))
(j:nat{j < table_len}) | false | false | Hacl.K256.PrecompTable.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val precomp_table_acc_inv : p: Spec.K256.PointOps.aff_point ->
table_len: Prims.nat{table_len * 15 <= Lib.IntTypes.max_size_t} ->
table: Lib.Sequence.lseq Lib.IntTypes.uint64 (table_len * 15) ->
j: Prims.nat{j < table_len}
-> Prims.logical | [] | Hacl.K256.PrecompTable.precomp_table_acc_inv | {
"file_name": "code/k256/Hacl.K256.PrecompTable.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
p: Spec.K256.PointOps.aff_point ->
table_len: Prims.nat{table_len * 15 <= Lib.IntTypes.max_size_t} ->
table: Lib.Sequence.lseq Lib.IntTypes.uint64 (table_len * 15) ->
j: Prims.nat{j < table_len}
-> Prims.logical | {
"end_col": 75,
"end_line": 111,
"start_col": 2,
"start_line": 108
} |
|
Prims.Tot | val mk_k256_precomp_base_table:SPT.mk_precomp_base_table S.proj_point U64 15ul 0ul | [
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Point",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.PrecompTable",
"short_module": "SPTK"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Hacl.Impl.K256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Point",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation.Definitions",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "Hacl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.K256",
"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
}
] | false | let mk_k256_precomp_base_table: SPT.mk_precomp_base_table S.proj_point U64 15ul 0ul = {
SPT.concr_ops = S.mk_k256_concrete_ops;
SPT.to_cm = mk_to_k256_comm_monoid;
SPT.to_list = proj_point_to_list;
SPT.lemma_refl = lemma_refl;
} | val mk_k256_precomp_base_table:SPT.mk_precomp_base_table S.proj_point U64 15ul 0ul
let mk_k256_precomp_base_table:SPT.mk_precomp_base_table S.proj_point U64 15ul 0ul = | false | null | false | {
SPT.concr_ops = S.mk_k256_concrete_ops;
SPT.to_cm = mk_to_k256_comm_monoid;
SPT.to_list = proj_point_to_list;
SPT.lemma_refl = lemma_refl
} | {
"checked_file": "Hacl.K256.PrecompTable.fsti.checked",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable.fsti.checked",
"Hacl.Impl.K256.Point.fsti.checked",
"Hacl.Impl.K256.Group.fst.checked",
"Hacl.Impl.Exponentiation.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.K256.PrecompTable.fsti"
} | [
"total"
] | [
"Hacl.Spec.PrecompBaseTable.Mkmk_precomp_base_table",
"Spec.K256.PointOps.proj_point",
"Lib.IntTypes.U64",
"FStar.UInt32.uint_to_t",
"Spec.K256.mk_k256_concrete_ops",
"Hacl.Impl.K256.Group.mk_to_k256_comm_monoid",
"Hacl.K256.PrecompTable.proj_point_to_list",
"Hacl.K256.PrecompTable.lemma_refl"
] | [] | module Hacl.K256.PrecompTable
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module LE = Lib.Exponentiation.Definition
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation.Definitions
module SPT = Hacl.Spec.PrecompBaseTable
module S = Spec.K256
open Hacl.Impl.K256.Point
include Hacl.Impl.K256.Group
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val proj_point_to_list: p:S.proj_point
-> x:list uint64{FStar.List.Tot.length x = 15 /\
mk_to_k256_comm_monoid.BE.linv (Seq.seq_of_list x)}
val lemma_refl: x:S.proj_point ->
Lemma (S.mk_k256_concrete_ops.SE.to.SE.refl x ==
mk_to_k256_comm_monoid.BE.refl (Seq.seq_of_list (proj_point_to_list x)))
inline_for_extraction noextract | false | false | Hacl.K256.PrecompTable.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_k256_precomp_base_table:SPT.mk_precomp_base_table S.proj_point U64 15ul 0ul | [] | Hacl.K256.PrecompTable.mk_k256_precomp_base_table | {
"file_name": "code/k256/Hacl.K256.PrecompTable.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Spec.PrecompBaseTable.mk_precomp_base_table Spec.K256.PointOps.proj_point
Lib.IntTypes.U64
(FStar.UInt32.uint_to_t 15 <: FStar.UInt32.t)
(FStar.UInt32.uint_to_t 0 <: FStar.UInt32.t) | {
"end_col": 30,
"end_line": 39,
"start_col": 2,
"start_line": 36
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def",
"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
}
] | false | let nat8 = Vale.Def.Words_s.nat8 | let nat8 = | false | null | false | Vale.Def.Words_s.nat8 | {
"checked_file": "Vale.Def.Types_s.fst.checked",
"dependencies": [
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Opaque_s.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Def.Types_s.fst"
} | [
"total"
] | [
"Vale.Def.Words_s.nat8"
] | [] | module Vale.Def.Types_s
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Lib.Seqs_s | false | true | Vale.Def.Types_s.fst | {
"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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val nat8 : Type0 | [] | Vale.Def.Types_s.nat8 | {
"file_name": "vale/specs/defs/Vale.Def.Types_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 39,
"end_line": 12,
"start_col": 18,
"start_line": 12
} |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.