file_name
stringlengths 5
52
| name
stringlengths 4
95
| original_source_type
stringlengths 0
23k
| source_type
stringlengths 9
23k
| source_definition
stringlengths 9
57.9k
| source
dict | source_range
dict | file_context
stringlengths 0
721k
| dependencies
dict | opens_and_abbrevs
listlengths 2
94
| vconfig
dict | interleaved
bool 1
class | verbose_type
stringlengths 1
7.42k
| effect
stringclasses 118
values | effect_flags
sequencelengths 0
2
| mutual_with
sequencelengths 0
11
| ideal_premises
sequencelengths 0
236
| proof_features
sequencelengths 0
1
| is_simple_lemma
bool 2
classes | is_div
bool 2
classes | is_proof
bool 2
classes | is_simply_typed
bool 2
classes | is_type
bool 2
classes | partial_definition
stringlengths 5
3.99k
| completed_definiton
stringlengths 1
1.63M
| isa_cross_project_example
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ID3.fst | ID3.return | val return (a: Type) (x: a) : repr a (as_pure_wp (fun p -> p x)) | val return (a: Type) (x: a) : repr a (as_pure_wp (fun p -> p x)) | let return (a : Type) (x : a) : repr a (as_pure_wp (fun p -> p x)) =
x | {
"file_name": "examples/layeredeffects/ID3.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 20,
"start_col": 0,
"start_line": 19
} | module ID3
// The base type of WPs
val w0 (a : Type u#a) : Type u#(max 1 a)
let w0 a = (a -> Type0) -> Type0
// We require monotonicity of them
let monotonic (w:w0 'a) =
forall p1 p2. (forall x. p1 x ==> p2 x) ==> w p1 ==> w p2
val w (a : Type u#a) : Type u#(max 1 a)
let w a = pure_wp a
let repr (a : Type) (wp : w a) : Type =
v:a{forall p. wp p ==> p v}
open FStar.Monotonic.Pure | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "ID3.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Type -> x: a -> ID3.repr a (FStar.Monotonic.Pure.as_pure_wp (fun p -> p x)) | Prims.Tot | [
"total"
] | [] | [
"ID3.repr",
"FStar.Monotonic.Pure.as_pure_wp",
"Prims.pure_post",
"Prims.pure_pre"
] | [] | false | false | false | false | false | let return (a: Type) (x: a) : repr a (as_pure_wp (fun p -> p x)) =
| x | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.swvalue | val swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t | val swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t | let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 18,
"end_line": 65,
"start_col": 0,
"start_line": 54
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | w: LowParse.Low.Writers.swriter s h0 space_beyond sout pout_from0 -> Prims.GTot t | Prims.GTot | [
"sometrivial"
] | [] | [
"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.Monotonic.HyperStack.mem",
"Prims.nat",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.swriter",
"FStar.Ghost.reveal",
"LowParse.Low.Writers.__proj__SWriter__item__v"
] | [] | false | false | false | false | false | let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t =
| Ghost.reveal w.v | false |
Hacl.IntTypes.Intrinsics_128.fst | Hacl.IntTypes.Intrinsics_128.add_carry_u64 | val add_carry_u64: add_carry_st U64 | val add_carry_u64: add_carry_st U64 | let add_carry_u64 cin x y r =
let res = to_u128 x +. to_u128 cin +. to_u128 y in
let c = to_u64 (res >>. 64ul) in
r.(0ul) <- to_u64 res;
c | {
"file_name": "code/fallback/Hacl.IntTypes.Intrinsics_128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 17,
"start_col": 0,
"start_line": 13
} | module Hacl.IntTypes.Intrinsics_128
open Hacl.IntTypes.Intrinsics
open Lib.IntTypes
open Lib.Buffer
(* Versions of add_carry_u64 and sub_borrow_u64 that rely on uint128 *)
#set-options "--fuel 0 --ifuel 0 --z3rlimit 200" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.IntTypes.Intrinsics.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.IntTypes.Intrinsics_128.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.IntTypes.Intrinsics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 200,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.IntTypes.Intrinsics.add_carry_st Lib.IntTypes.U64 | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.size",
"Prims.unit",
"Lib.Buffer.op_Array_Assignment",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.to_u64",
"Lib.IntTypes.U128",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Greater_Greater_Dot",
"Lib.IntTypes.op_Plus_Dot",
"Lib.IntTypes.to_u128"
] | [] | false | false | false | true | false | let add_carry_u64 cin x y r =
| let res = to_u128 x +. to_u128 cin +. to_u128 y in
let c = to_u64 (res >>. 64ul) in
r.(0ul) <- to_u64 res;
c | false |
ID3.fst | ID3.if_then_else_wp | val if_then_else_wp : wp1: ID3.w a -> wp2: ID3.w a -> p: Prims.bool -> Prims.pure_wp a | let if_then_else_wp #a (wp1 wp2:w a) (p:bool) =
elim_pure_wp_monotonicity_forall ();
as_pure_wp (fun post -> (p ==> wp1 post) /\ ((~p) ==> wp2 post)) | {
"file_name": "examples/layeredeffects/ID3.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 66,
"end_line": 43,
"start_col": 0,
"start_line": 41
} | module ID3
// The base type of WPs
val w0 (a : Type u#a) : Type u#(max 1 a)
let w0 a = (a -> Type0) -> Type0
// We require monotonicity of them
let monotonic (w:w0 'a) =
forall p1 p2. (forall x. p1 x ==> p2 x) ==> w p1 ==> w p2
val w (a : Type u#a) : Type u#(max 1 a)
let w a = pure_wp a
let repr (a : Type) (wp : w a) : Type =
v:a{forall p. wp p ==> p v}
open FStar.Monotonic.Pure
let return (a : Type) (x : a) : repr a (as_pure_wp (fun p -> p x)) =
x
unfold
let bind_wp #a #b (wp_v:w a) (wp_f:a -> w b) : w b =
elim_pure_wp_monotonicity_forall ();
as_pure_wp (fun p -> wp_v (fun x -> wp_f x p))
let bind (a b : Type) (wp_v : w a) (wp_f: a -> w b)
(v : repr a wp_v)
(f : (x:a -> repr b (wp_f x)))
: repr b (bind_wp wp_v wp_f)
= f v
let subcomp (a:Type) (wp1 wp2: w a)
(f : repr a wp1)
: Pure (repr a wp2)
(requires (forall p. wp2 p ==> wp1 p))
(ensures fun _ -> True)
= f | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "ID3.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | wp1: ID3.w a -> wp2: ID3.w a -> p: Prims.bool -> Prims.pure_wp a | Prims.Tot | [
"total"
] | [] | [
"ID3.w",
"Prims.bool",
"FStar.Monotonic.Pure.as_pure_wp",
"Prims.pure_post",
"Prims.l_and",
"Prims.l_imp",
"Prims.b2t",
"Prims.l_not",
"Prims.pure_pre",
"Prims.unit",
"FStar.Monotonic.Pure.elim_pure_wp_monotonicity_forall",
"Prims.pure_wp"
] | [] | false | false | false | true | false | let if_then_else_wp #a (wp1: w a) (wp2: w a) (p: bool) =
| elim_pure_wp_monotonicity_forall ();
as_pure_wp (fun post -> (p ==> wp1 post) /\ ((~p) ==> wp2 post)) | false |
|
ID3.fst | ID3.sum | val sum (l: list int) : IdT int | val sum (l: list int) : IdT int | let rec sum (l : list int) : IdT int
=
match l with
| [] -> 0
| x::xs ->
assert (xs << l); // this succeeds!!
x + sum xs | {
"file_name": "examples/layeredeffects/ID3.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 14,
"end_line": 90,
"start_col": 0,
"start_line": 84
} | module ID3
// The base type of WPs
val w0 (a : Type u#a) : Type u#(max 1 a)
let w0 a = (a -> Type0) -> Type0
// We require monotonicity of them
let monotonic (w:w0 'a) =
forall p1 p2. (forall x. p1 x ==> p2 x) ==> w p1 ==> w p2
val w (a : Type u#a) : Type u#(max 1 a)
let w a = pure_wp a
let repr (a : Type) (wp : w a) : Type =
v:a{forall p. wp p ==> p v}
open FStar.Monotonic.Pure
let return (a : Type) (x : a) : repr a (as_pure_wp (fun p -> p x)) =
x
unfold
let bind_wp #a #b (wp_v:w a) (wp_f:a -> w b) : w b =
elim_pure_wp_monotonicity_forall ();
as_pure_wp (fun p -> wp_v (fun x -> wp_f x p))
let bind (a b : Type) (wp_v : w a) (wp_f: a -> w b)
(v : repr a wp_v)
(f : (x:a -> repr b (wp_f x)))
: repr b (bind_wp wp_v wp_f)
= f v
let subcomp (a:Type) (wp1 wp2: w a)
(f : repr a wp1)
: Pure (repr a wp2)
(requires (forall p. wp2 p ==> wp1 p))
(ensures fun _ -> True)
= f
unfold
let if_then_else_wp #a (wp1 wp2:w a) (p:bool) =
elim_pure_wp_monotonicity_forall ();
as_pure_wp (fun post -> (p ==> wp1 post) /\ ((~p) ==> wp2 post))
let if_then_else (a : Type) (wp1 wp2 : w a) (f : repr a wp1) (g : repr a wp2) (p : bool) : Type =
repr a (if_then_else_wp wp1 wp2 p)
// requires to prove that
// p ==> f <: (if_then_else p f g)
// ~p ==> g <: (if_then_else p f g)
// if the effect definition fails, add lemmas for the
// above with smtpats
total
reifiable
reflectable
effect {
ID (a:Type) (_ : w a)
with {repr; return; bind; subcomp; if_then_else}
}
let lift_pure_nd (a:Type) (wp:pure_wp a) (f:unit -> PURE a wp) :
Pure (repr a wp) (requires (wp (fun _ -> True)))
(ensures (fun _ -> True))
= elim_pure_wp_monotonicity_forall ();
f ()
sub_effect PURE ~> ID = lift_pure_nd
(* Checking that it's kind of usable *)
val test_f : unit -> ID int (as_pure_wp (fun p -> p 5 /\ p 3))
let test_f () = 3
module T = FStar.Tactics.V2
let l () : int =
reify (test_f ())
effect Id (a:Type) (pre:pure_pre) (post:pure_post' a pre) =
ID a (as_pure_wp (fun (p:pure_post a) -> pre /\ (forall (pure_result:a). post pure_result ==> p pure_result)))
effect IdT (a:Type) = Id a True (fun _ -> True) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "ID3.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | l: Prims.list Prims.int -> ID3.IdT Prims.int | ID3.IdT | [] | [] | [
"Prims.list",
"Prims.int",
"Prims.op_Addition",
"ID3.sum",
"Prims.unit",
"Prims._assert",
"Prims.precedes"
] | [
"recursion"
] | false | true | false | false | false | let rec sum (l: list int) : IdT int =
| match l with
| [] -> 0
| x :: xs ->
assert (xs << l);
x + sum xs | false |
EtM.AE.fst | EtM.AE.mac_and_cpa_refine_ae | val mac_and_cpa_refine_ae
(ae_entries: Seq.seq log_entry)
(mac_entries: Seq.seq EtM.MAC.log_entry)
(cpa_entries: Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length ae_entries)) | val mac_and_cpa_refine_ae
(ae_entries: Seq.seq log_entry)
(mac_entries: Seq.seq EtM.MAC.log_entry)
(cpa_entries: Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length ae_entries)) | let rec mac_and_cpa_refine_ae (ae_entries:Seq.seq log_entry)
(mac_entries:Seq.seq EtM.MAC.log_entry)
(cpa_entries:Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length ae_entries)) =
Seq.length ae_entries == Seq.length mac_entries /\
Seq.length mac_entries == Seq.length cpa_entries /\
(if Seq.length ae_entries <> 0
then let ae_prefix, ae_last = Seq.un_snoc ae_entries in
let mac_prefix, mac_last = Seq.un_snoc mac_entries in
let cpa_prefix, cpa_last = Seq.un_snoc cpa_entries in
mac_and_cpa_refine_ae_entry ae_last mac_last cpa_last /\
mac_and_cpa_refine_ae ae_prefix mac_prefix cpa_prefix
else True) | {
"file_name": "examples/crypto/EtM.AE.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 13,
"end_line": 154,
"start_col": 0,
"start_line": 142
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module EtM.AE
open FStar.Seq
open FStar.Monotonic.Seq
open FStar.HyperStack
open FStar.HyperStack.ST
module MAC = EtM.MAC
open Platform.Bytes
open CoreCrypto
module CPA = EtM.CPA
module MAC = EtM.MAC
module Ideal = EtM.Ideal
module Plain = EtM.Plain
(*** Basic types ***)
type rid = erid
/// An AE cipher includes a mac tag
type cipher = (CPA.cipher * MAC.tag)
/// An AE log pairs plain texts with MAC'd ciphers
let log_entry = Plain.plain * cipher
type log_t (r:rid) = m_rref r (seq log_entry) grows
/// An AE key pairs an encryption key, ke, with a MAC'ing key, km,
/// with an invariant ensuring that their memory footprints of their
/// ideal state are disjoint.
///
/// Aside from this, we have an AE log, which is a view of the two
/// other logs.
noeq type key =
| Key: #region:rid
-> ke:CPA.key { extends (CPA.Key?.region ke) region }
-> km:MAC.key { extends (MAC.Key?.region km) region /\
disjoint( CPA.Key?.region ke) (MAC.Key?.region km) }
-> log:log_t region
-> key
(** Accessors for the three logs **)
/// ae log
let get_log (h:mem) (k:key) =
sel h k.log
/// mac log
let get_mac_log (h:mem) (k:key) =
sel h (MAC.Key?.log k.km)
/// cpa log
let get_cpa_log (h:mem) (k:key) =
sel h (CPA.Key?.log k.ke)
(*** Main invariant on the ideal state ***)
(** There are three components to this invariant
1. The CPA invariant (pairwise distinctness of IVs, notably)
2. mac_only_cpa_ciphers:
The MAC log and CPA logs are related, in that the MAC log only
contains entries for valid ciphers recorded the CPA log
3. mac_and_cpa_refine_ae:
The AE log is a combined view of the MAC and CPA logs Each of
its entries corresponds is combination of a single entry in the
MAC log and another in the CPA log
**)
let mac_cpa_related (mac:EtM.MAC.log_entry) (cpa:EtM.CPA.log_entry) =
CPA.Entry?.c cpa == fst mac
/// See the comment above, for part 2 of the invariant
/// -- As in EtM.CPA, we state the invariant recursively
/// matching entries up pointwise
let rec mac_only_cpa_ciphers (macs:Seq.seq EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length macs)) =
Seq.length macs == Seq.length cpas /\
(if Seq.length macs > 0 then
let macs, mac = Seq.un_snoc macs in
let cpas, cpa = Seq.un_snoc cpas in
mac_cpa_related mac cpa /\
mac_only_cpa_ciphers macs cpas
else True)
/// A lemma to intro/elim the recursive predicate above
let mac_only_cpa_ciphers_snoc (macs:Seq.seq EtM.MAC.log_entry) (mac:EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry) (cpa:EtM.CPA.log_entry)
: Lemma (mac_only_cpa_ciphers (snoc macs mac) (snoc cpas cpa) <==>
(mac_only_cpa_ciphers macs cpas /\ mac_cpa_related mac cpa))
= un_snoc_snoc macs mac;
un_snoc_snoc cpas cpa
/// A lemma that shows that if an cipher is MAC'd
/// then a corresponding entry must exists in the CPA log
let rec mac_only_cpa_ciphers_mem (macs:Seq.seq EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry)
(c:cipher)
: Lemma (requires (mac_only_cpa_ciphers macs cpas /\
Seq.mem c macs))
(ensures (exists p. Seq.mem (CPA.Entry p (fst c)) cpas))
(decreases (Seq.length macs))
= if Seq.length macs = 0 then
()
else let macs, mac = un_snoc macs in
let cpas, cpa = un_snoc cpas in
Seq.lemma_mem_snoc macs mac;
Seq.lemma_mem_snoc cpas cpa;
if mac = c then ()
else mac_only_cpa_ciphers_mem macs cpas c
/// See part 3 of the invariant:
/// -- An AE entry is related to a MAC and CPA entry
/// if its plain text + cipher appears in the CPA entry
/// and its cipher+tag appear in the MAC table
let mac_and_cpa_refine_ae_entry (ae:log_entry)
(mac:EtM.MAC.log_entry)
(cpa:EtM.CPA.log_entry) =
let p, c = ae in
mac == c /\
CPA.Entry p (fst c) == cpa
/// See part 3 of the invariant: | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Platform.Bytes.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Seq.fst.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"EtM.Plain.fsti.checked",
"EtM.MAC.fst.checked",
"EtM.Ideal.fsti.checked",
"EtM.CPA.fst.checked",
"CoreCrypto.fst.checked"
],
"interface_file": false,
"source_file": "EtM.AE.fst"
} | [
{
"abbrev": true,
"full_module": "EtM.Plain",
"short_module": "Plain"
},
{
"abbrev": true,
"full_module": "EtM.Ideal",
"short_module": "Ideal"
},
{
"abbrev": true,
"full_module": "EtM.MAC",
"short_module": "MAC"
},
{
"abbrev": true,
"full_module": "EtM.CPA",
"short_module": "CPA"
},
{
"abbrev": false,
"full_module": "CoreCrypto",
"short_module": null
},
{
"abbrev": false,
"full_module": "Platform.Bytes",
"short_module": null
},
{
"abbrev": true,
"full_module": "EtM.MAC",
"short_module": "MAC"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "EtM",
"short_module": null
},
{
"abbrev": false,
"full_module": "EtM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
ae_entries: FStar.Seq.Base.seq EtM.AE.log_entry ->
mac_entries: FStar.Seq.Base.seq EtM.MAC.log_entry ->
cpa_entries: FStar.Seq.Base.seq EtM.CPA.log_entry
-> Prims.Tot Type0 | Prims.Tot | [
"total",
""
] | [] | [
"FStar.Seq.Base.seq",
"EtM.AE.log_entry",
"EtM.MAC.log_entry",
"EtM.CPA.log_entry",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"Prims.op_disEquality",
"Prims.int",
"EtM.AE.mac_and_cpa_refine_ae_entry",
"EtM.AE.mac_and_cpa_refine_ae",
"Prims.logical",
"FStar.Pervasives.Native.tuple2",
"FStar.Seq.Properties.snoc",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd",
"FStar.Seq.Properties.un_snoc",
"Prims.bool",
"Prims.l_True"
] | [
"recursion"
] | false | false | false | true | true | let rec mac_and_cpa_refine_ae
(ae_entries: Seq.seq log_entry)
(mac_entries: Seq.seq EtM.MAC.log_entry)
(cpa_entries: Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length ae_entries)) =
| Seq.length ae_entries == Seq.length mac_entries /\ Seq.length mac_entries == Seq.length cpa_entries /\
(if Seq.length ae_entries <> 0
then
let ae_prefix, ae_last = Seq.un_snoc ae_entries in
let mac_prefix, mac_last = Seq.un_snoc mac_entries in
let cpa_prefix, cpa_last = Seq.un_snoc cpa_entries in
mac_and_cpa_refine_ae_entry ae_last mac_last cpa_last /\
mac_and_cpa_refine_ae ae_prefix mac_prefix cpa_prefix
else True) | false |
EtM.AE.fst | EtM.AE.mac_only_cpa_ciphers | val mac_only_cpa_ciphers (macs: Seq.seq EtM.MAC.log_entry) (cpas: Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length macs)) | val mac_only_cpa_ciphers (macs: Seq.seq EtM.MAC.log_entry) (cpas: Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length macs)) | let rec mac_only_cpa_ciphers (macs:Seq.seq EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length macs)) =
Seq.length macs == Seq.length cpas /\
(if Seq.length macs > 0 then
let macs, mac = Seq.un_snoc macs in
let cpas, cpa = Seq.un_snoc cpas in
mac_cpa_related mac cpa /\
mac_only_cpa_ciphers macs cpas
else True) | {
"file_name": "examples/crypto/EtM.AE.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 14,
"end_line": 101,
"start_col": 0,
"start_line": 92
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module EtM.AE
open FStar.Seq
open FStar.Monotonic.Seq
open FStar.HyperStack
open FStar.HyperStack.ST
module MAC = EtM.MAC
open Platform.Bytes
open CoreCrypto
module CPA = EtM.CPA
module MAC = EtM.MAC
module Ideal = EtM.Ideal
module Plain = EtM.Plain
(*** Basic types ***)
type rid = erid
/// An AE cipher includes a mac tag
type cipher = (CPA.cipher * MAC.tag)
/// An AE log pairs plain texts with MAC'd ciphers
let log_entry = Plain.plain * cipher
type log_t (r:rid) = m_rref r (seq log_entry) grows
/// An AE key pairs an encryption key, ke, with a MAC'ing key, km,
/// with an invariant ensuring that their memory footprints of their
/// ideal state are disjoint.
///
/// Aside from this, we have an AE log, which is a view of the two
/// other logs.
noeq type key =
| Key: #region:rid
-> ke:CPA.key { extends (CPA.Key?.region ke) region }
-> km:MAC.key { extends (MAC.Key?.region km) region /\
disjoint( CPA.Key?.region ke) (MAC.Key?.region km) }
-> log:log_t region
-> key
(** Accessors for the three logs **)
/// ae log
let get_log (h:mem) (k:key) =
sel h k.log
/// mac log
let get_mac_log (h:mem) (k:key) =
sel h (MAC.Key?.log k.km)
/// cpa log
let get_cpa_log (h:mem) (k:key) =
sel h (CPA.Key?.log k.ke)
(*** Main invariant on the ideal state ***)
(** There are three components to this invariant
1. The CPA invariant (pairwise distinctness of IVs, notably)
2. mac_only_cpa_ciphers:
The MAC log and CPA logs are related, in that the MAC log only
contains entries for valid ciphers recorded the CPA log
3. mac_and_cpa_refine_ae:
The AE log is a combined view of the MAC and CPA logs Each of
its entries corresponds is combination of a single entry in the
MAC log and another in the CPA log
**)
let mac_cpa_related (mac:EtM.MAC.log_entry) (cpa:EtM.CPA.log_entry) =
CPA.Entry?.c cpa == fst mac
/// See the comment above, for part 2 of the invariant
/// -- As in EtM.CPA, we state the invariant recursively | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Platform.Bytes.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Seq.fst.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"EtM.Plain.fsti.checked",
"EtM.MAC.fst.checked",
"EtM.Ideal.fsti.checked",
"EtM.CPA.fst.checked",
"CoreCrypto.fst.checked"
],
"interface_file": false,
"source_file": "EtM.AE.fst"
} | [
{
"abbrev": true,
"full_module": "EtM.Plain",
"short_module": "Plain"
},
{
"abbrev": true,
"full_module": "EtM.Ideal",
"short_module": "Ideal"
},
{
"abbrev": true,
"full_module": "EtM.MAC",
"short_module": "MAC"
},
{
"abbrev": true,
"full_module": "EtM.CPA",
"short_module": "CPA"
},
{
"abbrev": false,
"full_module": "CoreCrypto",
"short_module": null
},
{
"abbrev": false,
"full_module": "Platform.Bytes",
"short_module": null
},
{
"abbrev": true,
"full_module": "EtM.MAC",
"short_module": "MAC"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "EtM",
"short_module": null
},
{
"abbrev": false,
"full_module": "EtM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | macs: FStar.Seq.Base.seq EtM.MAC.log_entry -> cpas: FStar.Seq.Base.seq EtM.CPA.log_entry
-> Prims.Tot Type0 | Prims.Tot | [
"total",
""
] | [] | [
"FStar.Seq.Base.seq",
"EtM.MAC.log_entry",
"EtM.CPA.log_entry",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"Prims.op_GreaterThan",
"EtM.AE.mac_cpa_related",
"EtM.AE.mac_only_cpa_ciphers",
"Prims.logical",
"FStar.Pervasives.Native.tuple2",
"FStar.Seq.Properties.snoc",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd",
"FStar.Seq.Properties.un_snoc",
"Prims.bool",
"Prims.l_True"
] | [
"recursion"
] | false | false | false | true | true | let rec mac_only_cpa_ciphers (macs: Seq.seq EtM.MAC.log_entry) (cpas: Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length macs)) =
| Seq.length macs == Seq.length cpas /\
(if Seq.length macs > 0
then
let macs, mac = Seq.un_snoc macs in
let cpas, cpa = Seq.un_snoc cpas in
mac_cpa_related mac cpa /\ mac_only_cpa_ciphers macs cpas
else True) | false |
CQueue.LList.fst | CQueue.LList.ralloc | val ralloc (#a: Type0) (x: a)
: Steel (ref a)
emp
(fun r -> vptr r)
(requires fun _ -> True)
(ensures fun _ r h1 -> h1 (vptr r) == x /\ not (is_null r)) | val ralloc (#a: Type0) (x: a)
: Steel (ref a)
emp
(fun r -> vptr r)
(requires fun _ -> True)
(ensures fun _ r h1 -> h1 (vptr r) == x /\ not (is_null r)) | let ralloc (#a:Type0) (x:a) : Steel (ref a)
emp (fun r -> vptr r)
(requires fun _ -> True)
(ensures fun _ r h1 -> h1 (vptr r) == x /\ not (is_null r))
=
malloc x | {
"file_name": "share/steel/examples/steel/CQueue.LList.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 10,
"end_line": 145,
"start_col": 0,
"start_line": 140
} | module CQueue.LList
noeq
type cllist_ptrvalue (a: Type0) = {
head: ref (ccell_ptrvalue a);
tail: ref (ref (ccell_ptrvalue a));
all_or_none_null: squash (is_null head == is_null tail);
}
let cllist_ptrvalue_null a = {head = null; tail = null; all_or_none_null = ()}
let cllist_ptrvalue_is_null #a x = is_null x.head
let cllist_head #a c =
c.head
let cllist_tail #a c =
c.tail
#push-options "--ide_id_info_off"
let cllist0_refine
(#a: Type0)
(c: cllist_ptrvalue a)
(_: t_of emp)
: Tot prop
= cllist_ptrvalue_is_null c == false
// unfold
let cllist0_rewrite
(#a: Type0)
(c: cllist_ptrvalue a)
(_: t_of (emp `vrefine` cllist0_refine c))
: Tot (cllist_lvalue a)
= c
[@@ __steel_reduce__]
let cllist0 (a: Type0) (c: cllist_lvalue a) : Tot vprop =
(vptr (cllist_head c) `star` vptr (cllist_tail c))
// unfold
let cllist_rewrite
(#a: Type0)
(c: cllist_ptrvalue a)
(x: dtuple2 (cllist_lvalue a) (vdep_payload (emp `vrefine` cllist0_refine c `vrewrite` cllist0_rewrite c) (cllist0 a)))
: GTot (vllist a)
= let p =
dsnd #(cllist_lvalue a) #(vdep_payload (emp `vrefine` cllist0_refine c `vrewrite` cllist0_rewrite c) (cllist0 a)) x
in
{
vllist_head = fst p;
vllist_tail = snd p;
}
[@@ __steel_reduce__ ; __reduce__] // to avoid manual unfoldings through change_slprop
let cllist1
(#a: Type0)
(c: cllist_ptrvalue a)
: Tot vprop
= emp `vrefine` cllist0_refine c `vrewrite` cllist0_rewrite c `vdep` cllist0 a `vrewrite` cllist_rewrite c
let cllist_hp
#a c
= hp_of (cllist1 c)
let cllist_sel
#a c
= sel_of (cllist1 c)
let intro_cllist
#opened #a c
=
intro_vrefine emp (cllist0_refine c);
intro_vrewrite (emp `vrefine` cllist0_refine c) (cllist0_rewrite c);
reveal_star (vptr (cllist_head c)) (vptr (cllist_tail c));
intro_vdep
(emp `vrefine` cllist0_refine c `vrewrite` cllist0_rewrite c)
(vptr (cllist_head c) `star` vptr (cllist_tail c))
(cllist0 a);
intro_vrewrite
(emp `vrefine` cllist0_refine c `vrewrite` cllist0_rewrite c `vdep` cllist0 a)
(cllist_rewrite c);
change_slprop_rel
(cllist1 c)
(cllist c)
(fun x y -> x == y)
(fun m ->
assert_norm (hp_of (cllist1 c) == cllist_hp c);
assert_norm (sel_of (cllist1 c) m === sel_of (cllist c) m)
)
let elim_cllist_ghost
#opened #a c
=
change_slprop_rel
(cllist c)
(cllist1 c)
(fun x y -> x == y)
(fun m ->
assert_norm (hp_of (cllist1 c) == cllist_hp c);
assert_norm (sel_of (cllist1 c) m === sel_of (cllist c) m)
);
elim_vrewrite
(emp `vrefine` cllist0_refine c `vrewrite` cllist0_rewrite c `vdep` cllist0 a)
(cllist_rewrite c);
let c' : Ghost.erased (cllist_lvalue a) = elim_vdep
(emp `vrefine` cllist0_refine c `vrewrite` cllist0_rewrite c)
(cllist0 a)
in
elim_vrewrite (emp `vrefine` cllist0_refine c) (cllist0_rewrite c);
elim_vrefine emp (cllist0_refine c);
change_equal_slprop
(cllist0 a c')
(vptr (cllist_head (Ghost.reveal c')) `star` vptr (cllist_tail (Ghost.reveal c')));
reveal_star (vptr (cllist_head (Ghost.reveal c'))) (vptr (cllist_tail (Ghost.reveal c')));
c'
let elim_cllist
#opened #a c
=
let c2 = elim_cllist_ghost c in
let c : cllist_lvalue a = c in
change_equal_slprop (vptr (cllist_head c2)) (vptr (cllist_head c));
change_equal_slprop (vptr (cllist_tail c2)) (vptr (cllist_tail c));
return c
let cllist_not_null
#opened #a c
=
let c1 = elim_cllist_ghost c in
let c2 : cllist_lvalue a = c in
change_equal_slprop (vptr (cllist_head c1)) (vptr (cllist_head c2));
change_equal_slprop (vptr (cllist_tail c1)) (vptr (cllist_tail c2));
intro_cllist c2;
change_equal_slprop (cllist c2) (cllist c);
()
let freeable _ = True | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "CQueue.LList.fst"
} | [
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "CQueue.Cell",
"short_module": null
},
{
"abbrev": false,
"full_module": "CQueue",
"short_module": null
},
{
"abbrev": false,
"full_module": "CQueue",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: a -> Steel.Effect.Steel (Steel.Reference.ref a) | Steel.Effect.Steel | [] | [] | [
"Steel.Reference.malloc",
"Steel.Reference.ref",
"Steel.Effect.Common.emp",
"Steel.Reference.vptr",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.rmem",
"Prims.l_True",
"Prims.l_and",
"Prims.eq2",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of",
"Prims.b2t",
"Prims.op_Negation",
"Steel.Reference.is_null"
] | [] | false | true | false | false | false | let ralloc (#a: Type0) (x: a)
: Steel (ref a)
emp
(fun r -> vptr r)
(requires fun _ -> True)
(ensures fun _ r h1 -> h1 (vptr r) == x /\ not (is_null r)) =
| malloc x | false |
EtM.AE.fst | EtM.AE.invert_invariant | val invert_invariant (h: mem) (k: key) (c: cipher) (p: Plain.plain)
: Lemma
(requires
(invariant h k /\ Seq.mem c (get_mac_log h k) /\
Seq.mem (CPA.Entry p (fst c)) (get_cpa_log h k))) (ensures (Seq.mem (p, c) (get_log h k))) | val invert_invariant (h: mem) (k: key) (c: cipher) (p: Plain.plain)
: Lemma
(requires
(invariant h k /\ Seq.mem c (get_mac_log h k) /\
Seq.mem (CPA.Entry p (fst c)) (get_cpa_log h k))) (ensures (Seq.mem (p, c) (get_log h k))) | let invert_invariant (h:mem) (k:key) (c:cipher) (p:Plain.plain)
: Lemma (requires (invariant h k /\
Seq.mem c (get_mac_log h k) /\
Seq.mem (CPA.Entry p (fst c)) (get_cpa_log h k)))
(ensures (Seq.mem (p, c) (get_log h k)))
= let macs = get_mac_log h k in
let cpas = get_cpa_log h k in
let aes = get_log h k in
invert_invariant_aux c p macs cpas aes | {
"file_name": "examples/crypto/EtM.AE.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 247,
"start_col": 0,
"start_line": 239
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module EtM.AE
open FStar.Seq
open FStar.Monotonic.Seq
open FStar.HyperStack
open FStar.HyperStack.ST
module MAC = EtM.MAC
open Platform.Bytes
open CoreCrypto
module CPA = EtM.CPA
module MAC = EtM.MAC
module Ideal = EtM.Ideal
module Plain = EtM.Plain
(*** Basic types ***)
type rid = erid
/// An AE cipher includes a mac tag
type cipher = (CPA.cipher * MAC.tag)
/// An AE log pairs plain texts with MAC'd ciphers
let log_entry = Plain.plain * cipher
type log_t (r:rid) = m_rref r (seq log_entry) grows
/// An AE key pairs an encryption key, ke, with a MAC'ing key, km,
/// with an invariant ensuring that their memory footprints of their
/// ideal state are disjoint.
///
/// Aside from this, we have an AE log, which is a view of the two
/// other logs.
noeq type key =
| Key: #region:rid
-> ke:CPA.key { extends (CPA.Key?.region ke) region }
-> km:MAC.key { extends (MAC.Key?.region km) region /\
disjoint( CPA.Key?.region ke) (MAC.Key?.region km) }
-> log:log_t region
-> key
(** Accessors for the three logs **)
/// ae log
let get_log (h:mem) (k:key) =
sel h k.log
/// mac log
let get_mac_log (h:mem) (k:key) =
sel h (MAC.Key?.log k.km)
/// cpa log
let get_cpa_log (h:mem) (k:key) =
sel h (CPA.Key?.log k.ke)
(*** Main invariant on the ideal state ***)
(** There are three components to this invariant
1. The CPA invariant (pairwise distinctness of IVs, notably)
2. mac_only_cpa_ciphers:
The MAC log and CPA logs are related, in that the MAC log only
contains entries for valid ciphers recorded the CPA log
3. mac_and_cpa_refine_ae:
The AE log is a combined view of the MAC and CPA logs Each of
its entries corresponds is combination of a single entry in the
MAC log and another in the CPA log
**)
let mac_cpa_related (mac:EtM.MAC.log_entry) (cpa:EtM.CPA.log_entry) =
CPA.Entry?.c cpa == fst mac
/// See the comment above, for part 2 of the invariant
/// -- As in EtM.CPA, we state the invariant recursively
/// matching entries up pointwise
let rec mac_only_cpa_ciphers (macs:Seq.seq EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length macs)) =
Seq.length macs == Seq.length cpas /\
(if Seq.length macs > 0 then
let macs, mac = Seq.un_snoc macs in
let cpas, cpa = Seq.un_snoc cpas in
mac_cpa_related mac cpa /\
mac_only_cpa_ciphers macs cpas
else True)
/// A lemma to intro/elim the recursive predicate above
let mac_only_cpa_ciphers_snoc (macs:Seq.seq EtM.MAC.log_entry) (mac:EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry) (cpa:EtM.CPA.log_entry)
: Lemma (mac_only_cpa_ciphers (snoc macs mac) (snoc cpas cpa) <==>
(mac_only_cpa_ciphers macs cpas /\ mac_cpa_related mac cpa))
= un_snoc_snoc macs mac;
un_snoc_snoc cpas cpa
/// A lemma that shows that if an cipher is MAC'd
/// then a corresponding entry must exists in the CPA log
let rec mac_only_cpa_ciphers_mem (macs:Seq.seq EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry)
(c:cipher)
: Lemma (requires (mac_only_cpa_ciphers macs cpas /\
Seq.mem c macs))
(ensures (exists p. Seq.mem (CPA.Entry p (fst c)) cpas))
(decreases (Seq.length macs))
= if Seq.length macs = 0 then
()
else let macs, mac = un_snoc macs in
let cpas, cpa = un_snoc cpas in
Seq.lemma_mem_snoc macs mac;
Seq.lemma_mem_snoc cpas cpa;
if mac = c then ()
else mac_only_cpa_ciphers_mem macs cpas c
/// See part 3 of the invariant:
/// -- An AE entry is related to a MAC and CPA entry
/// if its plain text + cipher appears in the CPA entry
/// and its cipher+tag appear in the MAC table
let mac_and_cpa_refine_ae_entry (ae:log_entry)
(mac:EtM.MAC.log_entry)
(cpa:EtM.CPA.log_entry) =
let p, c = ae in
mac == c /\
CPA.Entry p (fst c) == cpa
/// See part 3 of the invariant:
/// -- A pointwise lifting the relation between the entries in the three logs
let rec mac_and_cpa_refine_ae (ae_entries:Seq.seq log_entry)
(mac_entries:Seq.seq EtM.MAC.log_entry)
(cpa_entries:Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length ae_entries)) =
Seq.length ae_entries == Seq.length mac_entries /\
Seq.length mac_entries == Seq.length cpa_entries /\
(if Seq.length ae_entries <> 0
then let ae_prefix, ae_last = Seq.un_snoc ae_entries in
let mac_prefix, mac_last = Seq.un_snoc mac_entries in
let cpa_prefix, cpa_last = Seq.un_snoc cpa_entries in
mac_and_cpa_refine_ae_entry ae_last mac_last cpa_last /\
mac_and_cpa_refine_ae ae_prefix mac_prefix cpa_prefix
else True)
/// A lemma to intro/elim the recursive predicate above
let mac_and_cpa_refine_ae_snoc (ae_entries:Seq.seq log_entry)
(mac_entries:Seq.seq EtM.MAC.log_entry)
(cpa_entries:Seq.seq EtM.CPA.log_entry)
(ae:log_entry)
(mac:EtM.MAC.log_entry)
(cpa:EtM.CPA.log_entry)
: Lemma (mac_and_cpa_refine_ae (snoc ae_entries ae)
(snoc mac_entries mac)
(snoc cpa_entries cpa) <==>
(mac_and_cpa_refine_ae ae_entries mac_entries cpa_entries /\
mac_and_cpa_refine_ae_entry ae mac cpa))
= Seq.un_snoc_snoc ae_entries ae;
Seq.un_snoc_snoc mac_entries mac;
Seq.un_snoc_snoc cpa_entries cpa
/// The main invariant:
/// -- A conjunction of the 3 components already mentioned
/// + some technical invariants about logs being allocated
let invariant (h:mem) (k:key) =
let log = get_log h k in
let mac_log = get_mac_log h k in
let cpa_log = get_cpa_log h k in
Map.contains (get_hmap h) k.region /\
Map.contains (get_hmap h) (MAC.Key?.region k.km) /\
Map.contains (get_hmap h) (CPA.Key?.region k.ke) /\
EtM.CPA.invariant (Key?.ke k) h /\
mac_only_cpa_ciphers (get_mac_log h k) (get_cpa_log h k) /\
mac_and_cpa_refine_ae (get_log h k) (get_mac_log h k) (get_cpa_log h k)
(*** The main AE lemma relying on the invariant ***)
(** For logs that respect the main invariant:
if (c, t) is a valid MAC
and (p, c) is a valid CPA
then (p, (c, t)) must be a in the AE log
The pairwise distinctness of ciphers in the CPA log
plays a crucial role.
For instance, using it, and knowing that (c, t) is a valid MAC,
we can conclude that their must be exactly one entry
in the CPA table containing c. **)
let rec invert_invariant_aux (c:cipher) (p:Plain.plain)
(macs:Seq.seq MAC.log_entry)
(cpas:Seq.seq CPA.log_entry)
(aes :Seq.seq log_entry)
: Lemma (requires (mac_only_cpa_ciphers macs cpas /\
mac_and_cpa_refine_ae aes macs cpas /\
CPA.pairwise_distinct_ivs cpas /\
Seq.mem c macs /\
Seq.mem (CPA.Entry p (fst c)) cpas))
(ensures (Seq.mem (p, c) aes))
(decreases (Seq.length macs))
= assert (Seq.length macs == Seq.length aes);
if Seq.length macs = 0 then ()
else let macs, mac = un_snoc macs in
let cpas, cpa = un_snoc cpas in
let aes, ae = un_snoc aes in
Seq.lemma_mem_snoc aes ae;
Seq.lemma_mem_snoc macs mac;
Seq.lemma_mem_snoc cpas cpa;
if mac = c then begin
assert (CPA.Entry?.c cpa == fst c);
CPA.invert_pairwise cpas cpa (fst c);
assert (not (Seq.mem (CPA.Entry p (fst c)) cpas));
assert (CPA.Entry?.plain cpa == p);
assert (ae = (p, c))
end
else if fst mac = fst c then begin
assert (CPA.Entry?.c cpa == fst c);
mac_only_cpa_ciphers_mem macs cpas c;
assert (exists q1. Seq.mem (CPA.Entry q1 (fst c)) cpas);
CPA.invert_pairwise cpas cpa (fst c)
end
else begin
assert (mac_and_cpa_refine_ae aes macs cpas);
mac_only_cpa_ciphers_snoc macs mac cpas cpa;
CPA.pairwise_snoc cpas cpa;
invert_invariant_aux c p macs cpas aes
end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Platform.Bytes.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Seq.fst.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"EtM.Plain.fsti.checked",
"EtM.MAC.fst.checked",
"EtM.Ideal.fsti.checked",
"EtM.CPA.fst.checked",
"CoreCrypto.fst.checked"
],
"interface_file": false,
"source_file": "EtM.AE.fst"
} | [
{
"abbrev": true,
"full_module": "EtM.Plain",
"short_module": "Plain"
},
{
"abbrev": true,
"full_module": "EtM.Ideal",
"short_module": "Ideal"
},
{
"abbrev": true,
"full_module": "EtM.MAC",
"short_module": "MAC"
},
{
"abbrev": true,
"full_module": "EtM.CPA",
"short_module": "CPA"
},
{
"abbrev": false,
"full_module": "CoreCrypto",
"short_module": null
},
{
"abbrev": false,
"full_module": "Platform.Bytes",
"short_module": null
},
{
"abbrev": true,
"full_module": "EtM.MAC",
"short_module": "MAC"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "EtM",
"short_module": null
},
{
"abbrev": false,
"full_module": "EtM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | h: FStar.Monotonic.HyperStack.mem -> k: EtM.AE.key -> c: EtM.AE.cipher -> p: EtM.Plain.plain
-> FStar.Pervasives.Lemma
(requires
EtM.AE.invariant h k /\ FStar.Seq.Properties.mem c (EtM.AE.get_mac_log h k) /\
FStar.Seq.Properties.mem (EtM.CPA.Entry p (FStar.Pervasives.Native.fst c))
(EtM.AE.get_cpa_log h k)) (ensures FStar.Seq.Properties.mem (p, c) (EtM.AE.get_log h k)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"EtM.AE.key",
"EtM.AE.cipher",
"EtM.Plain.plain",
"EtM.AE.invert_invariant_aux",
"FStar.Seq.Base.seq",
"EtM.AE.log_entry",
"EtM.AE.get_log",
"EtM.CPA.log_entry",
"EtM.AE.get_cpa_log",
"EtM.MAC.log_entry",
"EtM.AE.get_mac_log",
"Prims.unit",
"Prims.l_and",
"EtM.AE.invariant",
"Prims.b2t",
"FStar.Seq.Properties.mem",
"EtM.CPA.Entry",
"FStar.Pervasives.Native.fst",
"EtM.CPA.cipher",
"EtM.MAC.tag",
"Prims.squash",
"FStar.Pervasives.Native.Mktuple2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let invert_invariant (h: mem) (k: key) (c: cipher) (p: Plain.plain)
: Lemma
(requires
(invariant h k /\ Seq.mem c (get_mac_log h k) /\
Seq.mem (CPA.Entry p (fst c)) (get_cpa_log h k))) (ensures (Seq.mem (p, c) (get_log h k))) =
| let macs = get_mac_log h k in
let cpas = get_cpa_log h k in
let aes = get_log h k in
invert_invariant_aux c p macs cpas aes | false |
EtM.AE.fst | EtM.AE.mac_only_cpa_ciphers_snoc | val mac_only_cpa_ciphers_snoc
(macs: Seq.seq EtM.MAC.log_entry)
(mac: EtM.MAC.log_entry)
(cpas: Seq.seq EtM.CPA.log_entry)
(cpa: EtM.CPA.log_entry)
: Lemma
(mac_only_cpa_ciphers (snoc macs mac) (snoc cpas cpa) <==>
(mac_only_cpa_ciphers macs cpas /\ mac_cpa_related mac cpa)) | val mac_only_cpa_ciphers_snoc
(macs: Seq.seq EtM.MAC.log_entry)
(mac: EtM.MAC.log_entry)
(cpas: Seq.seq EtM.CPA.log_entry)
(cpa: EtM.CPA.log_entry)
: Lemma
(mac_only_cpa_ciphers (snoc macs mac) (snoc cpas cpa) <==>
(mac_only_cpa_ciphers macs cpas /\ mac_cpa_related mac cpa)) | let mac_only_cpa_ciphers_snoc (macs:Seq.seq EtM.MAC.log_entry) (mac:EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry) (cpa:EtM.CPA.log_entry)
: Lemma (mac_only_cpa_ciphers (snoc macs mac) (snoc cpas cpa) <==>
(mac_only_cpa_ciphers macs cpas /\ mac_cpa_related mac cpa))
= un_snoc_snoc macs mac;
un_snoc_snoc cpas cpa | {
"file_name": "examples/crypto/EtM.AE.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 25,
"end_line": 109,
"start_col": 0,
"start_line": 104
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module EtM.AE
open FStar.Seq
open FStar.Monotonic.Seq
open FStar.HyperStack
open FStar.HyperStack.ST
module MAC = EtM.MAC
open Platform.Bytes
open CoreCrypto
module CPA = EtM.CPA
module MAC = EtM.MAC
module Ideal = EtM.Ideal
module Plain = EtM.Plain
(*** Basic types ***)
type rid = erid
/// An AE cipher includes a mac tag
type cipher = (CPA.cipher * MAC.tag)
/// An AE log pairs plain texts with MAC'd ciphers
let log_entry = Plain.plain * cipher
type log_t (r:rid) = m_rref r (seq log_entry) grows
/// An AE key pairs an encryption key, ke, with a MAC'ing key, km,
/// with an invariant ensuring that their memory footprints of their
/// ideal state are disjoint.
///
/// Aside from this, we have an AE log, which is a view of the two
/// other logs.
noeq type key =
| Key: #region:rid
-> ke:CPA.key { extends (CPA.Key?.region ke) region }
-> km:MAC.key { extends (MAC.Key?.region km) region /\
disjoint( CPA.Key?.region ke) (MAC.Key?.region km) }
-> log:log_t region
-> key
(** Accessors for the three logs **)
/// ae log
let get_log (h:mem) (k:key) =
sel h k.log
/// mac log
let get_mac_log (h:mem) (k:key) =
sel h (MAC.Key?.log k.km)
/// cpa log
let get_cpa_log (h:mem) (k:key) =
sel h (CPA.Key?.log k.ke)
(*** Main invariant on the ideal state ***)
(** There are three components to this invariant
1. The CPA invariant (pairwise distinctness of IVs, notably)
2. mac_only_cpa_ciphers:
The MAC log and CPA logs are related, in that the MAC log only
contains entries for valid ciphers recorded the CPA log
3. mac_and_cpa_refine_ae:
The AE log is a combined view of the MAC and CPA logs Each of
its entries corresponds is combination of a single entry in the
MAC log and another in the CPA log
**)
let mac_cpa_related (mac:EtM.MAC.log_entry) (cpa:EtM.CPA.log_entry) =
CPA.Entry?.c cpa == fst mac
/// See the comment above, for part 2 of the invariant
/// -- As in EtM.CPA, we state the invariant recursively
/// matching entries up pointwise
let rec mac_only_cpa_ciphers (macs:Seq.seq EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length macs)) =
Seq.length macs == Seq.length cpas /\
(if Seq.length macs > 0 then
let macs, mac = Seq.un_snoc macs in
let cpas, cpa = Seq.un_snoc cpas in
mac_cpa_related mac cpa /\
mac_only_cpa_ciphers macs cpas
else True) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Platform.Bytes.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Seq.fst.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"EtM.Plain.fsti.checked",
"EtM.MAC.fst.checked",
"EtM.Ideal.fsti.checked",
"EtM.CPA.fst.checked",
"CoreCrypto.fst.checked"
],
"interface_file": false,
"source_file": "EtM.AE.fst"
} | [
{
"abbrev": true,
"full_module": "EtM.Plain",
"short_module": "Plain"
},
{
"abbrev": true,
"full_module": "EtM.Ideal",
"short_module": "Ideal"
},
{
"abbrev": true,
"full_module": "EtM.MAC",
"short_module": "MAC"
},
{
"abbrev": true,
"full_module": "EtM.CPA",
"short_module": "CPA"
},
{
"abbrev": false,
"full_module": "CoreCrypto",
"short_module": null
},
{
"abbrev": false,
"full_module": "Platform.Bytes",
"short_module": null
},
{
"abbrev": true,
"full_module": "EtM.MAC",
"short_module": "MAC"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "EtM",
"short_module": null
},
{
"abbrev": false,
"full_module": "EtM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
macs: FStar.Seq.Base.seq EtM.MAC.log_entry ->
mac: EtM.MAC.log_entry ->
cpas: FStar.Seq.Base.seq EtM.CPA.log_entry ->
cpa: EtM.CPA.log_entry
-> FStar.Pervasives.Lemma
(ensures
EtM.AE.mac_only_cpa_ciphers (FStar.Monotonic.Seq.snoc macs mac)
(FStar.Monotonic.Seq.snoc cpas cpa) <==>
EtM.AE.mac_only_cpa_ciphers macs cpas /\ EtM.AE.mac_cpa_related mac cpa) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"EtM.MAC.log_entry",
"EtM.CPA.log_entry",
"FStar.Seq.Properties.un_snoc_snoc",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_iff",
"EtM.AE.mac_only_cpa_ciphers",
"FStar.Monotonic.Seq.snoc",
"Prims.l_and",
"EtM.AE.mac_cpa_related",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let mac_only_cpa_ciphers_snoc
(macs: Seq.seq EtM.MAC.log_entry)
(mac: EtM.MAC.log_entry)
(cpas: Seq.seq EtM.CPA.log_entry)
(cpa: EtM.CPA.log_entry)
: Lemma
(mac_only_cpa_ciphers (snoc macs mac) (snoc cpas cpa) <==>
(mac_only_cpa_ciphers macs cpas /\ mac_cpa_related mac cpa)) =
| un_snoc_snoc macs mac;
un_snoc_snoc cpas cpa | false |
EtM.AE.fst | EtM.AE.mac_and_cpa_refine_ae_snoc | val mac_and_cpa_refine_ae_snoc
(ae_entries: Seq.seq log_entry)
(mac_entries: Seq.seq EtM.MAC.log_entry)
(cpa_entries: Seq.seq EtM.CPA.log_entry)
(ae: log_entry)
(mac: EtM.MAC.log_entry)
(cpa: EtM.CPA.log_entry)
: Lemma
(mac_and_cpa_refine_ae (snoc ae_entries ae) (snoc mac_entries mac) (snoc cpa_entries cpa) <==>
(mac_and_cpa_refine_ae ae_entries mac_entries cpa_entries /\
mac_and_cpa_refine_ae_entry ae mac cpa)) | val mac_and_cpa_refine_ae_snoc
(ae_entries: Seq.seq log_entry)
(mac_entries: Seq.seq EtM.MAC.log_entry)
(cpa_entries: Seq.seq EtM.CPA.log_entry)
(ae: log_entry)
(mac: EtM.MAC.log_entry)
(cpa: EtM.CPA.log_entry)
: Lemma
(mac_and_cpa_refine_ae (snoc ae_entries ae) (snoc mac_entries mac) (snoc cpa_entries cpa) <==>
(mac_and_cpa_refine_ae ae_entries mac_entries cpa_entries /\
mac_and_cpa_refine_ae_entry ae mac cpa)) | let mac_and_cpa_refine_ae_snoc (ae_entries:Seq.seq log_entry)
(mac_entries:Seq.seq EtM.MAC.log_entry)
(cpa_entries:Seq.seq EtM.CPA.log_entry)
(ae:log_entry)
(mac:EtM.MAC.log_entry)
(cpa:EtM.CPA.log_entry)
: Lemma (mac_and_cpa_refine_ae (snoc ae_entries ae)
(snoc mac_entries mac)
(snoc cpa_entries cpa) <==>
(mac_and_cpa_refine_ae ae_entries mac_entries cpa_entries /\
mac_and_cpa_refine_ae_entry ae mac cpa))
= Seq.un_snoc_snoc ae_entries ae;
Seq.un_snoc_snoc mac_entries mac;
Seq.un_snoc_snoc cpa_entries cpa | {
"file_name": "examples/crypto/EtM.AE.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 170,
"start_col": 0,
"start_line": 157
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module EtM.AE
open FStar.Seq
open FStar.Monotonic.Seq
open FStar.HyperStack
open FStar.HyperStack.ST
module MAC = EtM.MAC
open Platform.Bytes
open CoreCrypto
module CPA = EtM.CPA
module MAC = EtM.MAC
module Ideal = EtM.Ideal
module Plain = EtM.Plain
(*** Basic types ***)
type rid = erid
/// An AE cipher includes a mac tag
type cipher = (CPA.cipher * MAC.tag)
/// An AE log pairs plain texts with MAC'd ciphers
let log_entry = Plain.plain * cipher
type log_t (r:rid) = m_rref r (seq log_entry) grows
/// An AE key pairs an encryption key, ke, with a MAC'ing key, km,
/// with an invariant ensuring that their memory footprints of their
/// ideal state are disjoint.
///
/// Aside from this, we have an AE log, which is a view of the two
/// other logs.
noeq type key =
| Key: #region:rid
-> ke:CPA.key { extends (CPA.Key?.region ke) region }
-> km:MAC.key { extends (MAC.Key?.region km) region /\
disjoint( CPA.Key?.region ke) (MAC.Key?.region km) }
-> log:log_t region
-> key
(** Accessors for the three logs **)
/// ae log
let get_log (h:mem) (k:key) =
sel h k.log
/// mac log
let get_mac_log (h:mem) (k:key) =
sel h (MAC.Key?.log k.km)
/// cpa log
let get_cpa_log (h:mem) (k:key) =
sel h (CPA.Key?.log k.ke)
(*** Main invariant on the ideal state ***)
(** There are three components to this invariant
1. The CPA invariant (pairwise distinctness of IVs, notably)
2. mac_only_cpa_ciphers:
The MAC log and CPA logs are related, in that the MAC log only
contains entries for valid ciphers recorded the CPA log
3. mac_and_cpa_refine_ae:
The AE log is a combined view of the MAC and CPA logs Each of
its entries corresponds is combination of a single entry in the
MAC log and another in the CPA log
**)
let mac_cpa_related (mac:EtM.MAC.log_entry) (cpa:EtM.CPA.log_entry) =
CPA.Entry?.c cpa == fst mac
/// See the comment above, for part 2 of the invariant
/// -- As in EtM.CPA, we state the invariant recursively
/// matching entries up pointwise
let rec mac_only_cpa_ciphers (macs:Seq.seq EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length macs)) =
Seq.length macs == Seq.length cpas /\
(if Seq.length macs > 0 then
let macs, mac = Seq.un_snoc macs in
let cpas, cpa = Seq.un_snoc cpas in
mac_cpa_related mac cpa /\
mac_only_cpa_ciphers macs cpas
else True)
/// A lemma to intro/elim the recursive predicate above
let mac_only_cpa_ciphers_snoc (macs:Seq.seq EtM.MAC.log_entry) (mac:EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry) (cpa:EtM.CPA.log_entry)
: Lemma (mac_only_cpa_ciphers (snoc macs mac) (snoc cpas cpa) <==>
(mac_only_cpa_ciphers macs cpas /\ mac_cpa_related mac cpa))
= un_snoc_snoc macs mac;
un_snoc_snoc cpas cpa
/// A lemma that shows that if an cipher is MAC'd
/// then a corresponding entry must exists in the CPA log
let rec mac_only_cpa_ciphers_mem (macs:Seq.seq EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry)
(c:cipher)
: Lemma (requires (mac_only_cpa_ciphers macs cpas /\
Seq.mem c macs))
(ensures (exists p. Seq.mem (CPA.Entry p (fst c)) cpas))
(decreases (Seq.length macs))
= if Seq.length macs = 0 then
()
else let macs, mac = un_snoc macs in
let cpas, cpa = un_snoc cpas in
Seq.lemma_mem_snoc macs mac;
Seq.lemma_mem_snoc cpas cpa;
if mac = c then ()
else mac_only_cpa_ciphers_mem macs cpas c
/// See part 3 of the invariant:
/// -- An AE entry is related to a MAC and CPA entry
/// if its plain text + cipher appears in the CPA entry
/// and its cipher+tag appear in the MAC table
let mac_and_cpa_refine_ae_entry (ae:log_entry)
(mac:EtM.MAC.log_entry)
(cpa:EtM.CPA.log_entry) =
let p, c = ae in
mac == c /\
CPA.Entry p (fst c) == cpa
/// See part 3 of the invariant:
/// -- A pointwise lifting the relation between the entries in the three logs
let rec mac_and_cpa_refine_ae (ae_entries:Seq.seq log_entry)
(mac_entries:Seq.seq EtM.MAC.log_entry)
(cpa_entries:Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length ae_entries)) =
Seq.length ae_entries == Seq.length mac_entries /\
Seq.length mac_entries == Seq.length cpa_entries /\
(if Seq.length ae_entries <> 0
then let ae_prefix, ae_last = Seq.un_snoc ae_entries in
let mac_prefix, mac_last = Seq.un_snoc mac_entries in
let cpa_prefix, cpa_last = Seq.un_snoc cpa_entries in
mac_and_cpa_refine_ae_entry ae_last mac_last cpa_last /\
mac_and_cpa_refine_ae ae_prefix mac_prefix cpa_prefix
else True) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Platform.Bytes.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Seq.fst.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"EtM.Plain.fsti.checked",
"EtM.MAC.fst.checked",
"EtM.Ideal.fsti.checked",
"EtM.CPA.fst.checked",
"CoreCrypto.fst.checked"
],
"interface_file": false,
"source_file": "EtM.AE.fst"
} | [
{
"abbrev": true,
"full_module": "EtM.Plain",
"short_module": "Plain"
},
{
"abbrev": true,
"full_module": "EtM.Ideal",
"short_module": "Ideal"
},
{
"abbrev": true,
"full_module": "EtM.MAC",
"short_module": "MAC"
},
{
"abbrev": true,
"full_module": "EtM.CPA",
"short_module": "CPA"
},
{
"abbrev": false,
"full_module": "CoreCrypto",
"short_module": null
},
{
"abbrev": false,
"full_module": "Platform.Bytes",
"short_module": null
},
{
"abbrev": true,
"full_module": "EtM.MAC",
"short_module": "MAC"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "EtM",
"short_module": null
},
{
"abbrev": false,
"full_module": "EtM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
ae_entries: FStar.Seq.Base.seq EtM.AE.log_entry ->
mac_entries: FStar.Seq.Base.seq EtM.MAC.log_entry ->
cpa_entries: FStar.Seq.Base.seq EtM.CPA.log_entry ->
ae: EtM.AE.log_entry ->
mac: EtM.MAC.log_entry ->
cpa: EtM.CPA.log_entry
-> FStar.Pervasives.Lemma
(ensures
EtM.AE.mac_and_cpa_refine_ae (FStar.Monotonic.Seq.snoc ae_entries ae)
(FStar.Monotonic.Seq.snoc mac_entries mac)
(FStar.Monotonic.Seq.snoc cpa_entries cpa) <==>
EtM.AE.mac_and_cpa_refine_ae ae_entries mac_entries cpa_entries /\
EtM.AE.mac_and_cpa_refine_ae_entry ae mac cpa) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"EtM.AE.log_entry",
"EtM.MAC.log_entry",
"EtM.CPA.log_entry",
"FStar.Seq.Properties.un_snoc_snoc",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_iff",
"EtM.AE.mac_and_cpa_refine_ae",
"FStar.Monotonic.Seq.snoc",
"Prims.l_and",
"EtM.AE.mac_and_cpa_refine_ae_entry",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let mac_and_cpa_refine_ae_snoc
(ae_entries: Seq.seq log_entry)
(mac_entries: Seq.seq EtM.MAC.log_entry)
(cpa_entries: Seq.seq EtM.CPA.log_entry)
(ae: log_entry)
(mac: EtM.MAC.log_entry)
(cpa: EtM.CPA.log_entry)
: Lemma
(mac_and_cpa_refine_ae (snoc ae_entries ae) (snoc mac_entries mac) (snoc cpa_entries cpa) <==>
(mac_and_cpa_refine_ae ae_entries mac_entries cpa_entries /\
mac_and_cpa_refine_ae_entry ae mac cpa)) =
| Seq.un_snoc_snoc ae_entries ae;
Seq.un_snoc_snoc mac_entries mac;
Seq.un_snoc_snoc cpa_entries cpa | false |
ID3.fst | ID3.lift_pure_nd | val lift_pure_nd (a: Type) (wp: pure_wp a) (f: (unit -> PURE a wp))
: Pure (repr a wp) (requires (wp (fun _ -> True))) (ensures (fun _ -> True)) | val lift_pure_nd (a: Type) (wp: pure_wp a) (f: (unit -> PURE a wp))
: Pure (repr a wp) (requires (wp (fun _ -> True))) (ensures (fun _ -> True)) | let lift_pure_nd (a:Type) (wp:pure_wp a) (f:unit -> PURE a wp) :
Pure (repr a wp) (requires (wp (fun _ -> True)))
(ensures (fun _ -> True))
= elim_pure_wp_monotonicity_forall ();
f () | {
"file_name": "examples/layeredeffects/ID3.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 8,
"end_line": 65,
"start_col": 0,
"start_line": 61
} | module ID3
// The base type of WPs
val w0 (a : Type u#a) : Type u#(max 1 a)
let w0 a = (a -> Type0) -> Type0
// We require monotonicity of them
let monotonic (w:w0 'a) =
forall p1 p2. (forall x. p1 x ==> p2 x) ==> w p1 ==> w p2
val w (a : Type u#a) : Type u#(max 1 a)
let w a = pure_wp a
let repr (a : Type) (wp : w a) : Type =
v:a{forall p. wp p ==> p v}
open FStar.Monotonic.Pure
let return (a : Type) (x : a) : repr a (as_pure_wp (fun p -> p x)) =
x
unfold
let bind_wp #a #b (wp_v:w a) (wp_f:a -> w b) : w b =
elim_pure_wp_monotonicity_forall ();
as_pure_wp (fun p -> wp_v (fun x -> wp_f x p))
let bind (a b : Type) (wp_v : w a) (wp_f: a -> w b)
(v : repr a wp_v)
(f : (x:a -> repr b (wp_f x)))
: repr b (bind_wp wp_v wp_f)
= f v
let subcomp (a:Type) (wp1 wp2: w a)
(f : repr a wp1)
: Pure (repr a wp2)
(requires (forall p. wp2 p ==> wp1 p))
(ensures fun _ -> True)
= f
unfold
let if_then_else_wp #a (wp1 wp2:w a) (p:bool) =
elim_pure_wp_monotonicity_forall ();
as_pure_wp (fun post -> (p ==> wp1 post) /\ ((~p) ==> wp2 post))
let if_then_else (a : Type) (wp1 wp2 : w a) (f : repr a wp1) (g : repr a wp2) (p : bool) : Type =
repr a (if_then_else_wp wp1 wp2 p)
// requires to prove that
// p ==> f <: (if_then_else p f g)
// ~p ==> g <: (if_then_else p f g)
// if the effect definition fails, add lemmas for the
// above with smtpats
total
reifiable
reflectable
effect {
ID (a:Type) (_ : w a)
with {repr; return; bind; subcomp; if_then_else}
} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "ID3.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Type -> wp: Prims.pure_wp a -> f: (_: Prims.unit -> Prims.PURE a) -> Prims.Pure (ID3.repr a wp) | Prims.Pure | [] | [] | [
"Prims.pure_wp",
"Prims.unit",
"FStar.Monotonic.Pure.elim_pure_wp_monotonicity_forall",
"ID3.repr",
"Prims.l_True"
] | [] | false | false | false | false | false | let lift_pure_nd (a: Type) (wp: pure_wp a) (f: (unit -> PURE a wp))
: Pure (repr a wp) (requires (wp (fun _ -> True))) (ensures (fun _ -> True)) =
| elim_pure_wp_monotonicity_forall ();
f () | false |
ID3.fst | ID3.subcomp | val subcomp (a: Type) (wp1 wp2: w a) (f: repr a wp1)
: Pure (repr a wp2) (requires (forall p. wp2 p ==> wp1 p)) (ensures fun _ -> True) | val subcomp (a: Type) (wp1 wp2: w a) (f: repr a wp1)
: Pure (repr a wp2) (requires (forall p. wp2 p ==> wp1 p)) (ensures fun _ -> True) | let subcomp (a:Type) (wp1 wp2: w a)
(f : repr a wp1)
: Pure (repr a wp2)
(requires (forall p. wp2 p ==> wp1 p))
(ensures fun _ -> True)
= f | {
"file_name": "examples/layeredeffects/ID3.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 38,
"start_col": 0,
"start_line": 33
} | module ID3
// The base type of WPs
val w0 (a : Type u#a) : Type u#(max 1 a)
let w0 a = (a -> Type0) -> Type0
// We require monotonicity of them
let monotonic (w:w0 'a) =
forall p1 p2. (forall x. p1 x ==> p2 x) ==> w p1 ==> w p2
val w (a : Type u#a) : Type u#(max 1 a)
let w a = pure_wp a
let repr (a : Type) (wp : w a) : Type =
v:a{forall p. wp p ==> p v}
open FStar.Monotonic.Pure
let return (a : Type) (x : a) : repr a (as_pure_wp (fun p -> p x)) =
x
unfold
let bind_wp #a #b (wp_v:w a) (wp_f:a -> w b) : w b =
elim_pure_wp_monotonicity_forall ();
as_pure_wp (fun p -> wp_v (fun x -> wp_f x p))
let bind (a b : Type) (wp_v : w a) (wp_f: a -> w b)
(v : repr a wp_v)
(f : (x:a -> repr b (wp_f x)))
: repr b (bind_wp wp_v wp_f)
= f v | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "ID3.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Type -> wp1: ID3.w a -> wp2: ID3.w a -> f: ID3.repr a wp1 -> Prims.Pure (ID3.repr a wp2) | Prims.Pure | [] | [] | [
"ID3.w",
"ID3.repr",
"Prims.l_Forall",
"Prims.pure_post",
"Prims.l_imp",
"Prims.l_True"
] | [] | false | false | false | false | false | let subcomp (a: Type) (wp1 wp2: w a) (f: repr a wp1)
: Pure (repr a wp2) (requires (forall p. wp2 p ==> wp1 p)) (ensures fun _ -> True) =
| f | false |
ID3.fst | ID3.test_f | val test_f : unit -> ID int (as_pure_wp (fun p -> p 5 /\ p 3)) | val test_f : unit -> ID int (as_pure_wp (fun p -> p 5 /\ p 3)) | let test_f () = 3 | {
"file_name": "examples/layeredeffects/ID3.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 17,
"end_line": 72,
"start_col": 0,
"start_line": 72
} | module ID3
// The base type of WPs
val w0 (a : Type u#a) : Type u#(max 1 a)
let w0 a = (a -> Type0) -> Type0
// We require monotonicity of them
let monotonic (w:w0 'a) =
forall p1 p2. (forall x. p1 x ==> p2 x) ==> w p1 ==> w p2
val w (a : Type u#a) : Type u#(max 1 a)
let w a = pure_wp a
let repr (a : Type) (wp : w a) : Type =
v:a{forall p. wp p ==> p v}
open FStar.Monotonic.Pure
let return (a : Type) (x : a) : repr a (as_pure_wp (fun p -> p x)) =
x
unfold
let bind_wp #a #b (wp_v:w a) (wp_f:a -> w b) : w b =
elim_pure_wp_monotonicity_forall ();
as_pure_wp (fun p -> wp_v (fun x -> wp_f x p))
let bind (a b : Type) (wp_v : w a) (wp_f: a -> w b)
(v : repr a wp_v)
(f : (x:a -> repr b (wp_f x)))
: repr b (bind_wp wp_v wp_f)
= f v
let subcomp (a:Type) (wp1 wp2: w a)
(f : repr a wp1)
: Pure (repr a wp2)
(requires (forall p. wp2 p ==> wp1 p))
(ensures fun _ -> True)
= f
unfold
let if_then_else_wp #a (wp1 wp2:w a) (p:bool) =
elim_pure_wp_monotonicity_forall ();
as_pure_wp (fun post -> (p ==> wp1 post) /\ ((~p) ==> wp2 post))
let if_then_else (a : Type) (wp1 wp2 : w a) (f : repr a wp1) (g : repr a wp2) (p : bool) : Type =
repr a (if_then_else_wp wp1 wp2 p)
// requires to prove that
// p ==> f <: (if_then_else p f g)
// ~p ==> g <: (if_then_else p f g)
// if the effect definition fails, add lemmas for the
// above with smtpats
total
reifiable
reflectable
effect {
ID (a:Type) (_ : w a)
with {repr; return; bind; subcomp; if_then_else}
}
let lift_pure_nd (a:Type) (wp:pure_wp a) (f:unit -> PURE a wp) :
Pure (repr a wp) (requires (wp (fun _ -> True)))
(ensures (fun _ -> True))
= elim_pure_wp_monotonicity_forall ();
f ()
sub_effect PURE ~> ID = lift_pure_nd
(* Checking that it's kind of usable *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "ID3.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> ID3.ID Prims.int | ID3.ID | [] | [] | [
"Prims.unit",
"Prims.int"
] | [] | false | true | false | false | false | let test_f () =
| 3 | false |
Steel.Primitive.ForkJoin.Unix.fst | Steel.Primitive.ForkJoin.Unix.can_be_split_forall_frame | val can_be_split_forall_frame (#a: Type) (p q: post_t a) (frame: vprop) (x: a)
: Lemma (requires can_be_split_forall p q)
(ensures (frame `star` (p x)) `can_be_split` (frame `star` (q x))) | val can_be_split_forall_frame (#a: Type) (p q: post_t a) (frame: vprop) (x: a)
: Lemma (requires can_be_split_forall p q)
(ensures (frame `star` (p x)) `can_be_split` (frame `star` (q x))) | let can_be_split_forall_frame (#a:Type) (p q:post_t a) (frame:vprop) (x:a)
: Lemma (requires can_be_split_forall p q)
(ensures (frame `star` p x) `can_be_split` (frame `star` q x))
= let frame = hp_of frame in
let p = hp_of (p x) in
let q = hp_of (q x) in
reveal_can_be_split ();
assert (slimp p q);
slimp_star p q frame frame;
Steel.Memory.star_commutative p frame;
Steel.Memory.star_commutative q frame | {
"file_name": "lib/steel/Steel.Primitive.ForkJoin.Unix.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 40,
"end_line": 83,
"start_col": 0,
"start_line": 73
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Primitive.ForkJoin.Unix
(* This module shows that it's possible to layer continuations on top
of SteelT to get a direct style (or Unix style) fork/join. Very much a
prototype for now. *)
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open Steel.Reference
open Steel.Primitive.ForkJoin
#set-options "--warn_error -330" //turn off the experimental feature warning
#set-options "--ide_id_info_off"
// (* Some helpers *)
let change_slprop_equiv (p q : vprop)
(proof : squash (p `equiv` q))
: SteelT unit p (fun _ -> q)
= rewrite_slprop p q (fun _ -> proof; reveal_equiv p q)
let change_slprop_imp (p q : vprop)
(proof : squash (p `can_be_split` q))
: SteelT unit p (fun _ -> q)
= rewrite_slprop p q (fun _ -> proof; reveal_can_be_split ())
(* Continuations into unit, but parametrized by the final heap
* proposition and with an implicit framing. I think ideally these would
* also be parametric in the final type (instead of being hardcoded to
* unit) but that means fork needs to be extended to be polymorphic in
* at least one of the branches. *)
type steelK (t:Type u#aa) (framed:bool) (pre : vprop) (post:t->vprop) =
#frame:vprop -> #postf:vprop ->
f:(x:t -> SteelT unit (frame `star` post x) (fun _ -> postf)) ->
SteelT unit (frame `star` pre) (fun _ -> postf)
(* The classic continuation monad *)
let return_ a (x:a) (#[@@@ framing_implicit] p: a -> vprop) : steelK a true (return_pre (p x)) p =
fun k -> k x
private
let rearrange3 (p q r:vprop) : Lemma
(((p `star` q) `star` r) `equiv` (p `star` (r `star` q)))
= let open FStar.Tactics in
assert (((p `star` q) `star` r) `equiv` (p `star` (r `star` q))) by
(norm [delta_attr [`%__reduce__]]; canon' false (`true_p) (`true_p))
private
let equiv_symmetric (p1 p2:vprop)
: Lemma (requires p1 `equiv` p2) (ensures p2 `equiv` p1)
= reveal_equiv p1 p2;
equiv_symmetric (hp_of p1) (hp_of p2);
reveal_equiv p2 p1 | {
"checked_file": "/",
"dependencies": [
"Steel.Reference.fsti.checked",
"Steel.Primitive.ForkJoin.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.Primitive.ForkJoin.Unix.fst"
} | [
{
"abbrev": false,
"full_module": "Steel.Primitive.ForkJoin",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive.ForkJoin",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive.ForkJoin",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
p: Steel.Effect.Common.post_t a ->
q: Steel.Effect.Common.post_t a ->
frame: Steel.Effect.Common.vprop ->
x: a
-> FStar.Pervasives.Lemma (requires Steel.Effect.Common.can_be_split_forall p q)
(ensures
Steel.Effect.Common.can_be_split (Steel.Effect.Common.star frame (p x))
(Steel.Effect.Common.star frame (q x))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Steel.Effect.Common.post_t",
"Steel.Effect.Common.vprop",
"Steel.Memory.star_commutative",
"Prims.unit",
"Steel.Memory.slimp_star",
"Prims._assert",
"Steel.Memory.slimp",
"Steel.Effect.Common.reveal_can_be_split",
"Steel.Memory.slprop",
"Steel.Effect.Common.hp_of",
"Steel.Effect.Common.can_be_split_forall",
"Prims.squash",
"Steel.Effect.Common.can_be_split",
"Steel.Effect.Common.star",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let can_be_split_forall_frame (#a: Type) (p q: post_t a) (frame: vprop) (x: a)
: Lemma (requires can_be_split_forall p q)
(ensures (frame `star` (p x)) `can_be_split` (frame `star` (q x))) =
| let frame = hp_of frame in
let p = hp_of (p x) in
let q = hp_of (q x) in
reveal_can_be_split ();
assert (slimp p q);
slimp_star p q frame frame;
Steel.Memory.star_commutative p frame;
Steel.Memory.star_commutative q frame | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.wvalue | val wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t | val wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t | let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 18,
"end_line": 191,
"start_col": 0,
"start_line": 181
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | w: LowParse.Low.Writers.writer s h0 sout pout_from0 -> Prims.GTot t | Prims.GTot | [
"sometrivial"
] | [] | [
"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.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.writer",
"FStar.Ghost.reveal",
"LowParse.Low.Writers.__proj__Writer__item__v"
] | [] | false | false | false | false | false | let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t =
| Ghost.reveal w.v | false |
EtM.AE.fst | EtM.AE.keygen | val keygen (parent: rid)
: ST key
(requires (fun _ -> HyperStack.ST.witnessed (region_contains_pred parent)))
(ensures
(fun h0 k h1 ->
modifies Set.empty h0 h1 /\ extends k.region parent /\ fresh_region k.region h0 h1 /\
Map.contains (get_hmap h1) k.region /\ contains h1 k.log /\ sel h1 k.log == Seq.empty /\
invariant h1 k)) | val keygen (parent: rid)
: ST key
(requires (fun _ -> HyperStack.ST.witnessed (region_contains_pred parent)))
(ensures
(fun h0 k h1 ->
modifies Set.empty h0 h1 /\ extends k.region parent /\ fresh_region k.region h0 h1 /\
Map.contains (get_hmap h1) k.region /\ contains h1 k.log /\ sel h1 k.log == Seq.empty /\
invariant h1 k)) | let keygen (parent:rid)
: ST key
(requires (fun _ -> HyperStack.ST.witnessed (region_contains_pred parent)))
(ensures (fun h0 k h1 ->
modifies Set.empty h0 h1 /\
extends k.region parent /\
fresh_region k.region h0 h1 /\
Map.contains (get_hmap h1) k.region /\
contains h1 k.log /\
sel h1 k.log == Seq.empty /\
invariant h1 k)) =
let region = new_region parent in
let ke = CPA.keygen region in
let ka = MAC.keygen region in
let log = alloc_mref_seq region Seq.empty in
Key #region ke ka log | {
"file_name": "examples/crypto/EtM.AE.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 269,
"start_col": 0,
"start_line": 254
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module EtM.AE
open FStar.Seq
open FStar.Monotonic.Seq
open FStar.HyperStack
open FStar.HyperStack.ST
module MAC = EtM.MAC
open Platform.Bytes
open CoreCrypto
module CPA = EtM.CPA
module MAC = EtM.MAC
module Ideal = EtM.Ideal
module Plain = EtM.Plain
(*** Basic types ***)
type rid = erid
/// An AE cipher includes a mac tag
type cipher = (CPA.cipher * MAC.tag)
/// An AE log pairs plain texts with MAC'd ciphers
let log_entry = Plain.plain * cipher
type log_t (r:rid) = m_rref r (seq log_entry) grows
/// An AE key pairs an encryption key, ke, with a MAC'ing key, km,
/// with an invariant ensuring that their memory footprints of their
/// ideal state are disjoint.
///
/// Aside from this, we have an AE log, which is a view of the two
/// other logs.
noeq type key =
| Key: #region:rid
-> ke:CPA.key { extends (CPA.Key?.region ke) region }
-> km:MAC.key { extends (MAC.Key?.region km) region /\
disjoint( CPA.Key?.region ke) (MAC.Key?.region km) }
-> log:log_t region
-> key
(** Accessors for the three logs **)
/// ae log
let get_log (h:mem) (k:key) =
sel h k.log
/// mac log
let get_mac_log (h:mem) (k:key) =
sel h (MAC.Key?.log k.km)
/// cpa log
let get_cpa_log (h:mem) (k:key) =
sel h (CPA.Key?.log k.ke)
(*** Main invariant on the ideal state ***)
(** There are three components to this invariant
1. The CPA invariant (pairwise distinctness of IVs, notably)
2. mac_only_cpa_ciphers:
The MAC log and CPA logs are related, in that the MAC log only
contains entries for valid ciphers recorded the CPA log
3. mac_and_cpa_refine_ae:
The AE log is a combined view of the MAC and CPA logs Each of
its entries corresponds is combination of a single entry in the
MAC log and another in the CPA log
**)
let mac_cpa_related (mac:EtM.MAC.log_entry) (cpa:EtM.CPA.log_entry) =
CPA.Entry?.c cpa == fst mac
/// See the comment above, for part 2 of the invariant
/// -- As in EtM.CPA, we state the invariant recursively
/// matching entries up pointwise
let rec mac_only_cpa_ciphers (macs:Seq.seq EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length macs)) =
Seq.length macs == Seq.length cpas /\
(if Seq.length macs > 0 then
let macs, mac = Seq.un_snoc macs in
let cpas, cpa = Seq.un_snoc cpas in
mac_cpa_related mac cpa /\
mac_only_cpa_ciphers macs cpas
else True)
/// A lemma to intro/elim the recursive predicate above
let mac_only_cpa_ciphers_snoc (macs:Seq.seq EtM.MAC.log_entry) (mac:EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry) (cpa:EtM.CPA.log_entry)
: Lemma (mac_only_cpa_ciphers (snoc macs mac) (snoc cpas cpa) <==>
(mac_only_cpa_ciphers macs cpas /\ mac_cpa_related mac cpa))
= un_snoc_snoc macs mac;
un_snoc_snoc cpas cpa
/// A lemma that shows that if an cipher is MAC'd
/// then a corresponding entry must exists in the CPA log
let rec mac_only_cpa_ciphers_mem (macs:Seq.seq EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry)
(c:cipher)
: Lemma (requires (mac_only_cpa_ciphers macs cpas /\
Seq.mem c macs))
(ensures (exists p. Seq.mem (CPA.Entry p (fst c)) cpas))
(decreases (Seq.length macs))
= if Seq.length macs = 0 then
()
else let macs, mac = un_snoc macs in
let cpas, cpa = un_snoc cpas in
Seq.lemma_mem_snoc macs mac;
Seq.lemma_mem_snoc cpas cpa;
if mac = c then ()
else mac_only_cpa_ciphers_mem macs cpas c
/// See part 3 of the invariant:
/// -- An AE entry is related to a MAC and CPA entry
/// if its plain text + cipher appears in the CPA entry
/// and its cipher+tag appear in the MAC table
let mac_and_cpa_refine_ae_entry (ae:log_entry)
(mac:EtM.MAC.log_entry)
(cpa:EtM.CPA.log_entry) =
let p, c = ae in
mac == c /\
CPA.Entry p (fst c) == cpa
/// See part 3 of the invariant:
/// -- A pointwise lifting the relation between the entries in the three logs
let rec mac_and_cpa_refine_ae (ae_entries:Seq.seq log_entry)
(mac_entries:Seq.seq EtM.MAC.log_entry)
(cpa_entries:Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length ae_entries)) =
Seq.length ae_entries == Seq.length mac_entries /\
Seq.length mac_entries == Seq.length cpa_entries /\
(if Seq.length ae_entries <> 0
then let ae_prefix, ae_last = Seq.un_snoc ae_entries in
let mac_prefix, mac_last = Seq.un_snoc mac_entries in
let cpa_prefix, cpa_last = Seq.un_snoc cpa_entries in
mac_and_cpa_refine_ae_entry ae_last mac_last cpa_last /\
mac_and_cpa_refine_ae ae_prefix mac_prefix cpa_prefix
else True)
/// A lemma to intro/elim the recursive predicate above
let mac_and_cpa_refine_ae_snoc (ae_entries:Seq.seq log_entry)
(mac_entries:Seq.seq EtM.MAC.log_entry)
(cpa_entries:Seq.seq EtM.CPA.log_entry)
(ae:log_entry)
(mac:EtM.MAC.log_entry)
(cpa:EtM.CPA.log_entry)
: Lemma (mac_and_cpa_refine_ae (snoc ae_entries ae)
(snoc mac_entries mac)
(snoc cpa_entries cpa) <==>
(mac_and_cpa_refine_ae ae_entries mac_entries cpa_entries /\
mac_and_cpa_refine_ae_entry ae mac cpa))
= Seq.un_snoc_snoc ae_entries ae;
Seq.un_snoc_snoc mac_entries mac;
Seq.un_snoc_snoc cpa_entries cpa
/// The main invariant:
/// -- A conjunction of the 3 components already mentioned
/// + some technical invariants about logs being allocated
let invariant (h:mem) (k:key) =
let log = get_log h k in
let mac_log = get_mac_log h k in
let cpa_log = get_cpa_log h k in
Map.contains (get_hmap h) k.region /\
Map.contains (get_hmap h) (MAC.Key?.region k.km) /\
Map.contains (get_hmap h) (CPA.Key?.region k.ke) /\
EtM.CPA.invariant (Key?.ke k) h /\
mac_only_cpa_ciphers (get_mac_log h k) (get_cpa_log h k) /\
mac_and_cpa_refine_ae (get_log h k) (get_mac_log h k) (get_cpa_log h k)
(*** The main AE lemma relying on the invariant ***)
(** For logs that respect the main invariant:
if (c, t) is a valid MAC
and (p, c) is a valid CPA
then (p, (c, t)) must be a in the AE log
The pairwise distinctness of ciphers in the CPA log
plays a crucial role.
For instance, using it, and knowing that (c, t) is a valid MAC,
we can conclude that their must be exactly one entry
in the CPA table containing c. **)
let rec invert_invariant_aux (c:cipher) (p:Plain.plain)
(macs:Seq.seq MAC.log_entry)
(cpas:Seq.seq CPA.log_entry)
(aes :Seq.seq log_entry)
: Lemma (requires (mac_only_cpa_ciphers macs cpas /\
mac_and_cpa_refine_ae aes macs cpas /\
CPA.pairwise_distinct_ivs cpas /\
Seq.mem c macs /\
Seq.mem (CPA.Entry p (fst c)) cpas))
(ensures (Seq.mem (p, c) aes))
(decreases (Seq.length macs))
= assert (Seq.length macs == Seq.length aes);
if Seq.length macs = 0 then ()
else let macs, mac = un_snoc macs in
let cpas, cpa = un_snoc cpas in
let aes, ae = un_snoc aes in
Seq.lemma_mem_snoc aes ae;
Seq.lemma_mem_snoc macs mac;
Seq.lemma_mem_snoc cpas cpa;
if mac = c then begin
assert (CPA.Entry?.c cpa == fst c);
CPA.invert_pairwise cpas cpa (fst c);
assert (not (Seq.mem (CPA.Entry p (fst c)) cpas));
assert (CPA.Entry?.plain cpa == p);
assert (ae = (p, c))
end
else if fst mac = fst c then begin
assert (CPA.Entry?.c cpa == fst c);
mac_only_cpa_ciphers_mem macs cpas c;
assert (exists q1. Seq.mem (CPA.Entry q1 (fst c)) cpas);
CPA.invert_pairwise cpas cpa (fst c)
end
else begin
assert (mac_and_cpa_refine_ae aes macs cpas);
mac_only_cpa_ciphers_snoc macs mac cpas cpa;
CPA.pairwise_snoc cpas cpa;
invert_invariant_aux c p macs cpas aes
end
/// Lifting the lemma above to work on the current state, h
let invert_invariant (h:mem) (k:key) (c:cipher) (p:Plain.plain)
: Lemma (requires (invariant h k /\
Seq.mem c (get_mac_log h k) /\
Seq.mem (CPA.Entry p (fst c)) (get_cpa_log h k)))
(ensures (Seq.mem (p, c) (get_log h k)))
= let macs = get_mac_log h k in
let cpas = get_cpa_log h k in
let aes = get_log h k in
invert_invariant_aux c p macs cpas aes
(*** Main interface of AE
keygen, encrypt, decrypt ***)
/// keygen: create a fresh key in the caller's region | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Platform.Bytes.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Seq.fst.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"EtM.Plain.fsti.checked",
"EtM.MAC.fst.checked",
"EtM.Ideal.fsti.checked",
"EtM.CPA.fst.checked",
"CoreCrypto.fst.checked"
],
"interface_file": false,
"source_file": "EtM.AE.fst"
} | [
{
"abbrev": true,
"full_module": "EtM.Plain",
"short_module": "Plain"
},
{
"abbrev": true,
"full_module": "EtM.Ideal",
"short_module": "Ideal"
},
{
"abbrev": true,
"full_module": "EtM.MAC",
"short_module": "MAC"
},
{
"abbrev": true,
"full_module": "EtM.CPA",
"short_module": "CPA"
},
{
"abbrev": false,
"full_module": "CoreCrypto",
"short_module": null
},
{
"abbrev": false,
"full_module": "Platform.Bytes",
"short_module": null
},
{
"abbrev": true,
"full_module": "EtM.MAC",
"short_module": "MAC"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "EtM",
"short_module": null
},
{
"abbrev": false,
"full_module": "EtM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | parent: EtM.AE.rid -> FStar.HyperStack.ST.ST EtM.AE.key | FStar.HyperStack.ST.ST | [] | [] | [
"EtM.AE.rid",
"EtM.AE.Key",
"EtM.AE.key",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"EtM.AE.log_entry",
"FStar.Monotonic.Seq.grows",
"FStar.Monotonic.Seq.alloc_mref_seq",
"FStar.Seq.Base.empty",
"EtM.MAC.key",
"EtM.MAC.keygen",
"EtM.CPA.key",
"EtM.CPA.keygen",
"FStar.Monotonic.HyperHeap.rid",
"FStar.HyperStack.ST.new_region",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.witnessed",
"FStar.HyperStack.ST.region_contains_pred",
"Prims.l_and",
"FStar.Monotonic.HyperStack.modifies",
"FStar.Set.empty",
"Prims.b2t",
"FStar.Monotonic.HyperHeap.extends",
"EtM.AE.__proj__Key__item__region",
"FStar.Monotonic.HyperStack.fresh_region",
"FStar.Map.contains",
"FStar.Monotonic.Heap.heap",
"FStar.Monotonic.HyperStack.get_hmap",
"FStar.Monotonic.HyperStack.contains",
"EtM.AE.__proj__Key__item__log",
"Prims.eq2",
"FStar.Monotonic.HyperStack.sel",
"EtM.AE.invariant"
] | [] | false | true | false | false | false | let keygen (parent: rid)
: ST key
(requires (fun _ -> HyperStack.ST.witnessed (region_contains_pred parent)))
(ensures
(fun h0 k h1 ->
modifies Set.empty h0 h1 /\ extends k.region parent /\ fresh_region k.region h0 h1 /\
Map.contains (get_hmap h1) k.region /\ contains h1 k.log /\ sel h1 k.log == Seq.empty /\
invariant h1 k)) =
| let region = new_region parent in
let ke = CPA.keygen region in
let ka = MAC.keygen region in
let log = alloc_mref_seq region Seq.empty in
Key #region ke ka log | false |
Pulse.Lib.HashTable.Type.fsti | Pulse.Lib.HashTable.Type.exploded_vp | val exploded_vp
(#k: eqtype)
(#v: Type0)
(r: ref (ht_t k v))
(ht: ht_t k v)
(r_sz: ref pos_us)
(r_hashf: ref (k -> SZ.t))
(r_contents: ref (V.vec (cell k v)))
: vprop | val exploded_vp
(#k: eqtype)
(#v: Type0)
(r: ref (ht_t k v))
(ht: ht_t k v)
(r_sz: ref pos_us)
(r_hashf: ref (k -> SZ.t))
(r_contents: ref (V.vec (cell k v)))
: vprop | let exploded_vp (#k:eqtype) (#v:Type0)
(r:ref (ht_t k v))
(ht:ht_t k v)
(r_sz:ref pos_us)
(r_hashf:ref (k -> SZ.t))
(r_contents:ref (V.vec (cell k v))) : vprop =
pts_to r_sz ht.sz **
pts_to r_hashf ht.hashf **
pts_to r_contents ht.contents **
token r r_sz r_hashf r_contents | {
"file_name": "share/steel/examples/pulse/lib/Pulse.Lib.HashTable.Type.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 33,
"end_line": 53,
"start_col": 0,
"start_line": 44
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Pulse.Lib.HashTable.Type
open Pulse.Lib.Pervasives
module V = Pulse.Lib.Vec
module R = Pulse.Lib.Reference
module SZ = FStar.SizeT
open Pulse.Lib.HashTable.Spec
type pos_us = n:SZ.t{SZ.v n > 0}
[@@ no_auto_projectors;
Rust_generics_bounds [["Copy"; "PartialEq"; "Clone"];
["Clone"]] ]
noeq
type ht_t (keyt:eqtype) (valt:Type) = {
sz : pos_us;
hashf: keyt -> SZ.t;
contents : V.vec (cell keyt valt);
}
val token (#k:eqtype) (#v:Type0)
(r:ref (ht_t k v))
(r_sz:ref pos_us)
(r_hashf:ref (k -> SZ.t))
(r_contents:ref (V.vec (cell k v))) : vprop | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Vec.fsti.checked",
"Pulse.Lib.Reference.fsti.checked",
"Pulse.Lib.Pervasives.fst.checked",
"Pulse.Lib.HashTable.Spec.fst.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Lib.HashTable.Type.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "SZ"
},
{
"abbrev": true,
"full_module": "Pulse.Lib.Reference",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "Pulse.Lib.Vec",
"short_module": "V"
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.HashTable.Spec",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "SZ"
},
{
"abbrev": true,
"full_module": "Pulse.Lib.Reference",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "Pulse.Lib.Vec",
"short_module": "V"
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.HashTable",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.HashTable",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: Pulse.Lib.Reference.ref (Pulse.Lib.HashTable.Type.ht_t k v) ->
ht: Pulse.Lib.HashTable.Type.ht_t k v ->
r_sz: Pulse.Lib.Reference.ref Pulse.Lib.HashTable.Type.pos_us ->
r_hashf: Pulse.Lib.Reference.ref (_: k -> FStar.SizeT.t) ->
r_contents: Pulse.Lib.Reference.ref (Pulse.Lib.Vec.vec (Pulse.Lib.HashTable.Spec.cell k v))
-> Pulse.Lib.Core.vprop | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"Pulse.Lib.Reference.ref",
"Pulse.Lib.HashTable.Type.ht_t",
"Pulse.Lib.HashTable.Type.pos_us",
"FStar.SizeT.t",
"Pulse.Lib.Vec.vec",
"Pulse.Lib.HashTable.Spec.cell",
"Pulse.Lib.Core.op_Star_Star",
"Pulse.Lib.Reference.pts_to",
"PulseCore.FractionalPermission.full_perm",
"Pulse.Lib.HashTable.Type.__proj__Mkht_t__item__sz",
"Pulse.Lib.HashTable.Type.__proj__Mkht_t__item__hashf",
"Pulse.Lib.HashTable.Type.__proj__Mkht_t__item__contents",
"Pulse.Lib.HashTable.Type.token",
"Pulse.Lib.Core.vprop"
] | [] | false | false | false | false | false | let exploded_vp
(#k: eqtype)
(#v: Type0)
(r: ref (ht_t k v))
(ht: ht_t k v)
(r_sz: ref pos_us)
(r_hashf: ref (k -> SZ.t))
(r_contents: ref (V.vec (cell k v)))
: vprop =
| ((pts_to r_sz ht.sz ** pts_to r_hashf ht.hashf) ** pts_to r_contents ht.contents) **
token r r_sz r_hashf r_contents | false |
Steel.PCMFrac.fst | Steel.PCMFrac.fractional | val fractional : a: Type -> Type | let fractional (a:Type u#a) = option (a & perm) | {
"file_name": "lib/steel/Steel.PCMFrac.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 47,
"end_line": 6,
"start_col": 0,
"start_line": 6
} | module Steel.PCMFrac
include FStar.PCM
include Steel.FractionalPermission
open FStar.Real | {
"checked_file": "/",
"dependencies": [
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.PCMFrac.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Type -> Type | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"Steel.FractionalPermission.perm"
] | [] | false | false | false | true | true | let fractional (a: Type u#a) =
| option (a & perm) | false |
|
Steel.Primitive.ForkJoin.Unix.fst | Steel.Primitive.ForkJoin.Unix.rearrange3 | val rearrange3 (p q r: vprop) : Lemma (((p `star` q) `star` r) `equiv` (p `star` (r `star` q))) | val rearrange3 (p q r: vprop) : Lemma (((p `star` q) `star` r) `equiv` (p `star` (r `star` q))) | let rearrange3 (p q r:vprop) : Lemma
(((p `star` q) `star` r) `equiv` (p `star` (r `star` q)))
= let open FStar.Tactics in
assert (((p `star` q) `star` r) `equiv` (p `star` (r `star` q))) by
(norm [delta_attr [`%__reduce__]]; canon' false (`true_p) (`true_p)) | {
"file_name": "lib/steel/Steel.Primitive.ForkJoin.Unix.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 81,
"end_line": 63,
"start_col": 0,
"start_line": 59
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Primitive.ForkJoin.Unix
(* This module shows that it's possible to layer continuations on top
of SteelT to get a direct style (or Unix style) fork/join. Very much a
prototype for now. *)
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open Steel.Reference
open Steel.Primitive.ForkJoin
#set-options "--warn_error -330" //turn off the experimental feature warning
#set-options "--ide_id_info_off"
// (* Some helpers *)
let change_slprop_equiv (p q : vprop)
(proof : squash (p `equiv` q))
: SteelT unit p (fun _ -> q)
= rewrite_slprop p q (fun _ -> proof; reveal_equiv p q)
let change_slprop_imp (p q : vprop)
(proof : squash (p `can_be_split` q))
: SteelT unit p (fun _ -> q)
= rewrite_slprop p q (fun _ -> proof; reveal_can_be_split ())
(* Continuations into unit, but parametrized by the final heap
* proposition and with an implicit framing. I think ideally these would
* also be parametric in the final type (instead of being hardcoded to
* unit) but that means fork needs to be extended to be polymorphic in
* at least one of the branches. *)
type steelK (t:Type u#aa) (framed:bool) (pre : vprop) (post:t->vprop) =
#frame:vprop -> #postf:vprop ->
f:(x:t -> SteelT unit (frame `star` post x) (fun _ -> postf)) ->
SteelT unit (frame `star` pre) (fun _ -> postf)
(* The classic continuation monad *)
let return_ a (x:a) (#[@@@ framing_implicit] p: a -> vprop) : steelK a true (return_pre (p x)) p =
fun k -> k x | {
"checked_file": "/",
"dependencies": [
"Steel.Reference.fsti.checked",
"Steel.Primitive.ForkJoin.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.Primitive.ForkJoin.Unix.fst"
} | [
{
"abbrev": false,
"full_module": "Steel.Primitive.ForkJoin",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive.ForkJoin",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive.ForkJoin",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: Steel.Effect.Common.vprop -> q: Steel.Effect.Common.vprop -> r: Steel.Effect.Common.vprop
-> FStar.Pervasives.Lemma
(ensures
Steel.Effect.Common.equiv (Steel.Effect.Common.star (Steel.Effect.Common.star p q) r)
(Steel.Effect.Common.star p (Steel.Effect.Common.star r q))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Steel.Effect.Common.vprop",
"FStar.Tactics.Effect.assert_by_tactic",
"Steel.Effect.Common.equiv",
"Steel.Effect.Common.star",
"Prims.unit",
"Steel.Effect.Common.canon'",
"FStar.Stubs.Tactics.V1.Builtins.norm",
"Prims.Cons",
"FStar.Pervasives.norm_step",
"FStar.Pervasives.delta_attr",
"Prims.string",
"Prims.Nil",
"Prims.l_True",
"Prims.squash",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let rearrange3 (p q r: vprop) : Lemma (((p `star` q) `star` r) `equiv` (p `star` (r `star` q))) =
| let open FStar.Tactics in
FStar.Tactics.Effect.assert_by_tactic (((p `star` q) `star` r) `equiv` (p `star` (r `star` q)))
(fun _ ->
();
(norm [delta_attr [`%__reduce__]];
canon' false (`true_p) (`true_p))) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.lwvalue | val lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t) | val lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t) | let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 18,
"end_line": 321,
"start_col": 0,
"start_line": 311
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | w: LowParse.Low.Writers.lwriter s h0 sout pout_from0 -> Prims.GTot (Prims.list t) | Prims.GTot | [
"sometrivial"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.lwriter",
"FStar.Ghost.reveal",
"Prims.list",
"LowParse.Low.Writers.__proj__LWriter__item__v"
] | [] | false | false | false | false | false | let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t) =
| Ghost.reveal w.v | false |
EtM.AE.fst | EtM.AE.mac_only_cpa_ciphers_mem | val mac_only_cpa_ciphers_mem
(macs: Seq.seq EtM.MAC.log_entry)
(cpas: Seq.seq EtM.CPA.log_entry)
(c: cipher)
: Lemma (requires (mac_only_cpa_ciphers macs cpas /\ Seq.mem c macs))
(ensures (exists p. Seq.mem (CPA.Entry p (fst c)) cpas))
(decreases (Seq.length macs)) | val mac_only_cpa_ciphers_mem
(macs: Seq.seq EtM.MAC.log_entry)
(cpas: Seq.seq EtM.CPA.log_entry)
(c: cipher)
: Lemma (requires (mac_only_cpa_ciphers macs cpas /\ Seq.mem c macs))
(ensures (exists p. Seq.mem (CPA.Entry p (fst c)) cpas))
(decreases (Seq.length macs)) | let rec mac_only_cpa_ciphers_mem (macs:Seq.seq EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry)
(c:cipher)
: Lemma (requires (mac_only_cpa_ciphers macs cpas /\
Seq.mem c macs))
(ensures (exists p. Seq.mem (CPA.Entry p (fst c)) cpas))
(decreases (Seq.length macs))
= if Seq.length macs = 0 then
()
else let macs, mac = un_snoc macs in
let cpas, cpa = un_snoc cpas in
Seq.lemma_mem_snoc macs mac;
Seq.lemma_mem_snoc cpas cpa;
if mac = c then ()
else mac_only_cpa_ciphers_mem macs cpas c | {
"file_name": "examples/crypto/EtM.AE.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 52,
"end_line": 127,
"start_col": 0,
"start_line": 113
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module EtM.AE
open FStar.Seq
open FStar.Monotonic.Seq
open FStar.HyperStack
open FStar.HyperStack.ST
module MAC = EtM.MAC
open Platform.Bytes
open CoreCrypto
module CPA = EtM.CPA
module MAC = EtM.MAC
module Ideal = EtM.Ideal
module Plain = EtM.Plain
(*** Basic types ***)
type rid = erid
/// An AE cipher includes a mac tag
type cipher = (CPA.cipher * MAC.tag)
/// An AE log pairs plain texts with MAC'd ciphers
let log_entry = Plain.plain * cipher
type log_t (r:rid) = m_rref r (seq log_entry) grows
/// An AE key pairs an encryption key, ke, with a MAC'ing key, km,
/// with an invariant ensuring that their memory footprints of their
/// ideal state are disjoint.
///
/// Aside from this, we have an AE log, which is a view of the two
/// other logs.
noeq type key =
| Key: #region:rid
-> ke:CPA.key { extends (CPA.Key?.region ke) region }
-> km:MAC.key { extends (MAC.Key?.region km) region /\
disjoint( CPA.Key?.region ke) (MAC.Key?.region km) }
-> log:log_t region
-> key
(** Accessors for the three logs **)
/// ae log
let get_log (h:mem) (k:key) =
sel h k.log
/// mac log
let get_mac_log (h:mem) (k:key) =
sel h (MAC.Key?.log k.km)
/// cpa log
let get_cpa_log (h:mem) (k:key) =
sel h (CPA.Key?.log k.ke)
(*** Main invariant on the ideal state ***)
(** There are three components to this invariant
1. The CPA invariant (pairwise distinctness of IVs, notably)
2. mac_only_cpa_ciphers:
The MAC log and CPA logs are related, in that the MAC log only
contains entries for valid ciphers recorded the CPA log
3. mac_and_cpa_refine_ae:
The AE log is a combined view of the MAC and CPA logs Each of
its entries corresponds is combination of a single entry in the
MAC log and another in the CPA log
**)
let mac_cpa_related (mac:EtM.MAC.log_entry) (cpa:EtM.CPA.log_entry) =
CPA.Entry?.c cpa == fst mac
/// See the comment above, for part 2 of the invariant
/// -- As in EtM.CPA, we state the invariant recursively
/// matching entries up pointwise
let rec mac_only_cpa_ciphers (macs:Seq.seq EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length macs)) =
Seq.length macs == Seq.length cpas /\
(if Seq.length macs > 0 then
let macs, mac = Seq.un_snoc macs in
let cpas, cpa = Seq.un_snoc cpas in
mac_cpa_related mac cpa /\
mac_only_cpa_ciphers macs cpas
else True)
/// A lemma to intro/elim the recursive predicate above
let mac_only_cpa_ciphers_snoc (macs:Seq.seq EtM.MAC.log_entry) (mac:EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry) (cpa:EtM.CPA.log_entry)
: Lemma (mac_only_cpa_ciphers (snoc macs mac) (snoc cpas cpa) <==>
(mac_only_cpa_ciphers macs cpas /\ mac_cpa_related mac cpa))
= un_snoc_snoc macs mac;
un_snoc_snoc cpas cpa
/// A lemma that shows that if an cipher is MAC'd | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Platform.Bytes.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Seq.fst.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"EtM.Plain.fsti.checked",
"EtM.MAC.fst.checked",
"EtM.Ideal.fsti.checked",
"EtM.CPA.fst.checked",
"CoreCrypto.fst.checked"
],
"interface_file": false,
"source_file": "EtM.AE.fst"
} | [
{
"abbrev": true,
"full_module": "EtM.Plain",
"short_module": "Plain"
},
{
"abbrev": true,
"full_module": "EtM.Ideal",
"short_module": "Ideal"
},
{
"abbrev": true,
"full_module": "EtM.MAC",
"short_module": "MAC"
},
{
"abbrev": true,
"full_module": "EtM.CPA",
"short_module": "CPA"
},
{
"abbrev": false,
"full_module": "CoreCrypto",
"short_module": null
},
{
"abbrev": false,
"full_module": "Platform.Bytes",
"short_module": null
},
{
"abbrev": true,
"full_module": "EtM.MAC",
"short_module": "MAC"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "EtM",
"short_module": null
},
{
"abbrev": false,
"full_module": "EtM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
macs: FStar.Seq.Base.seq EtM.MAC.log_entry ->
cpas: FStar.Seq.Base.seq EtM.CPA.log_entry ->
c: EtM.AE.cipher
-> FStar.Pervasives.Lemma
(requires EtM.AE.mac_only_cpa_ciphers macs cpas /\ FStar.Seq.Properties.mem c macs)
(ensures
exists (p: EtM.Plain.plain).
FStar.Seq.Properties.mem (EtM.CPA.Entry p (FStar.Pervasives.Native.fst c)) cpas)
(decreases FStar.Seq.Base.length macs) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Seq.Base.seq",
"EtM.MAC.log_entry",
"EtM.CPA.log_entry",
"EtM.AE.cipher",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.bool",
"FStar.Pervasives.Native.tuple2",
"EtM.CPA.cipher",
"EtM.MAC.tag",
"EtM.AE.mac_only_cpa_ciphers_mem",
"Prims.unit",
"FStar.Seq.Properties.lemma_mem_snoc",
"FStar.Monotonic.Seq.un_snoc",
"Prims.l_and",
"EtM.AE.mac_only_cpa_ciphers",
"Prims.b2t",
"FStar.Seq.Properties.mem",
"Prims.squash",
"Prims.l_Exists",
"EtM.Plain.plain",
"EtM.CPA.Entry",
"FStar.Pervasives.Native.fst",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec mac_only_cpa_ciphers_mem
(macs: Seq.seq EtM.MAC.log_entry)
(cpas: Seq.seq EtM.CPA.log_entry)
(c: cipher)
: Lemma (requires (mac_only_cpa_ciphers macs cpas /\ Seq.mem c macs))
(ensures (exists p. Seq.mem (CPA.Entry p (fst c)) cpas))
(decreases (Seq.length macs)) =
| if Seq.length macs = 0
then ()
else
let macs, mac = un_snoc macs in
let cpas, cpa = un_snoc cpas in
Seq.lemma_mem_snoc macs mac;
Seq.lemma_mem_snoc cpas cpa;
if mac = c then () else mac_only_cpa_ciphers_mem macs cpas c | false |
Steel.Primitive.ForkJoin.Unix.fst | Steel.Primitive.ForkJoin.Unix.equiv_symmetric | val equiv_symmetric (p1 p2: vprop) : Lemma (requires p1 `equiv` p2) (ensures p2 `equiv` p1) | val equiv_symmetric (p1 p2: vprop) : Lemma (requires p1 `equiv` p2) (ensures p2 `equiv` p1) | let equiv_symmetric (p1 p2:vprop)
: Lemma (requires p1 `equiv` p2) (ensures p2 `equiv` p1)
= reveal_equiv p1 p2;
equiv_symmetric (hp_of p1) (hp_of p2);
reveal_equiv p2 p1 | {
"file_name": "lib/steel/Steel.Primitive.ForkJoin.Unix.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 22,
"end_line": 70,
"start_col": 0,
"start_line": 66
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Primitive.ForkJoin.Unix
(* This module shows that it's possible to layer continuations on top
of SteelT to get a direct style (or Unix style) fork/join. Very much a
prototype for now. *)
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open Steel.Reference
open Steel.Primitive.ForkJoin
#set-options "--warn_error -330" //turn off the experimental feature warning
#set-options "--ide_id_info_off"
// (* Some helpers *)
let change_slprop_equiv (p q : vprop)
(proof : squash (p `equiv` q))
: SteelT unit p (fun _ -> q)
= rewrite_slprop p q (fun _ -> proof; reveal_equiv p q)
let change_slprop_imp (p q : vprop)
(proof : squash (p `can_be_split` q))
: SteelT unit p (fun _ -> q)
= rewrite_slprop p q (fun _ -> proof; reveal_can_be_split ())
(* Continuations into unit, but parametrized by the final heap
* proposition and with an implicit framing. I think ideally these would
* also be parametric in the final type (instead of being hardcoded to
* unit) but that means fork needs to be extended to be polymorphic in
* at least one of the branches. *)
type steelK (t:Type u#aa) (framed:bool) (pre : vprop) (post:t->vprop) =
#frame:vprop -> #postf:vprop ->
f:(x:t -> SteelT unit (frame `star` post x) (fun _ -> postf)) ->
SteelT unit (frame `star` pre) (fun _ -> postf)
(* The classic continuation monad *)
let return_ a (x:a) (#[@@@ framing_implicit] p: a -> vprop) : steelK a true (return_pre (p x)) p =
fun k -> k x
private
let rearrange3 (p q r:vprop) : Lemma
(((p `star` q) `star` r) `equiv` (p `star` (r `star` q)))
= let open FStar.Tactics in
assert (((p `star` q) `star` r) `equiv` (p `star` (r `star` q))) by
(norm [delta_attr [`%__reduce__]]; canon' false (`true_p) (`true_p)) | {
"checked_file": "/",
"dependencies": [
"Steel.Reference.fsti.checked",
"Steel.Primitive.ForkJoin.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.Primitive.ForkJoin.Unix.fst"
} | [
{
"abbrev": false,
"full_module": "Steel.Primitive.ForkJoin",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive.ForkJoin",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive.ForkJoin",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p1: Steel.Effect.Common.vprop -> p2: Steel.Effect.Common.vprop
-> FStar.Pervasives.Lemma (requires Steel.Effect.Common.equiv p1 p2)
(ensures Steel.Effect.Common.equiv p2 p1) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.reveal_equiv",
"Prims.unit",
"Steel.Memory.equiv_symmetric",
"Steel.Effect.Common.hp_of",
"Steel.Effect.Common.equiv",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let equiv_symmetric (p1 p2: vprop) : Lemma (requires p1 `equiv` p2) (ensures p2 `equiv` p1) =
| reveal_equiv p1 p2;
equiv_symmetric (hp_of p1) (hp_of p2);
reveal_equiv p2 p1 | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.owvalue | val owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t) | val owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t) | let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 18,
"end_line": 561,
"start_col": 0,
"start_line": 551
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | w: LowParse.Low.Writers.owriter s h0 sout pout_from0
-> Prims.GTot (FStar.Pervasives.Native.option t) | Prims.GTot | [
"sometrivial"
] | [] | [
"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.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.owriter",
"FStar.Ghost.reveal",
"LowParse.Low.Writers.__proj__OWriter__item__v"
] | [] | false | false | false | false | false | let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t) =
| Ghost.reveal w.v | false |
Vale.AES.X64.AESopt.fst | Vale.AES.X64.AESopt.va_qcode_Loop6x | val va_qcode_Loop6x
(va_mods: va_mods_t)
(alg: algorithm)
(h_LE y_orig y_prev: quad32)
(count: nat)
(iv_b in0_b in_b out_b scratch_b: buffer128)
(plain_quads: (seq quad32))
(key_words: (seq nat32))
(round_keys: (seq quad32))
(keys_b hkeys_b: buffer128)
(ctr_BE_orig ctr_BE: quad32)
: (va_quickCode (quad32) (va_code_Loop6x alg)) | val va_qcode_Loop6x
(va_mods: va_mods_t)
(alg: algorithm)
(h_LE y_orig y_prev: quad32)
(count: nat)
(iv_b in0_b in_b out_b scratch_b: buffer128)
(plain_quads: (seq quad32))
(key_words: (seq nat32))
(round_keys: (seq quad32))
(keys_b hkeys_b: buffer128)
(ctr_BE_orig ctr_BE: quad32)
: (va_quickCode (quad32) (va_code_Loop6x alg)) | let va_qcode_Loop6x (va_mods:va_mods_t) (alg:algorithm) (h_LE:quad32) (y_orig:quad32)
(y_prev:quad32) (count:nat) (iv_b:buffer128) (in0_b:buffer128) (in_b:buffer128) (out_b:buffer128)
(scratch_b:buffer128) (plain_quads:(seq quad32)) (key_words:(seq nat32)) (round_keys:(seq
quad32)) (keys_b:buffer128) (hkeys_b:buffer128) (ctr_BE_orig:quad32) (ctr_BE:quad32) :
(va_quickCode (quad32) (va_code_Loop6x alg)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in let
(prev:Vale.Math.Poly2_s.poly) = add (add (Vale.Math.Poly2.Bits_s.of_quad32 (va_get_xmm 8 va_s))
(Vale.Math.Poly2.Bits_s.of_quad32 (va_get_xmm 4 va_s))) (Vale.Math.Poly2.Bits_s.of_quad32
(Vale.X64.Decls.buffer128_read scratch_b 1 (va_get_mem_heaplet 3 va_s))) in let
(y_prev:Vale.Def.Types_s.quad32) = Vale.Def.Types_s.reverse_bytes_quad32
(Vale.Math.Poly2.Bits_s.to_quad32 prev) in va_qAssertSquash va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 1100 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(count - 2 >= 0 /\ count - 2 >= 0 /\ (fun a_1906 (s_1907:(FStar.Seq.Base.seq a_1906))
(i_1908:Prims.nat) (j_1909:Prims.nat) -> let (j_1869:Prims.nat) = j_1909 in Prims.b2t
(Prims.op_AmpAmp (Prims.op_LessThanOrEqual i_1908 j_1869) (Prims.op_LessThanOrEqual j_1869
(FStar.Seq.Base.length #a_1906 s_1907)))) Vale.X64.Decls.quad32 (Vale.X64.Decls.s128
(va_get_mem_heaplet 6 va_s) in0_b) ((count - 2) `op_Multiply` 6) ((count - 2) `op_Multiply` 6 +
6)) (fun _ -> let (data:(FStar.Seq.Base.seq Vale.X64.Decls.quad32)) = FStar.Seq.Base.slice
#Vale.X64.Decls.quad32 (Vale.X64.Decls.s128 (va_get_mem_heaplet 6 va_s) in0_b) ((count - 2)
`op_Multiply` 6) ((count - 2) `op_Multiply` 6 + 6) in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 1101 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.Math.Poly2.Bits.lemma_of_to_quad32 prev) (va_qAssertSquash va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 1103 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(count - 1 >= 0) (fun _ -> va_QBind va_range1
"***** PRECONDITION NOT MET AT line 1103 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_partial alg h_LE y_prev data count (count - 1) iv_b in0_b in_b scratch_b
key_words round_keys keys_b hkeys_b ctr_BE) (fun (va_s:va_state) (init:quad32_6) -> let
(ctrs:(six_of Vale.Def.Types_s.quad32)) = make_six_of #Vale.Def.Types_s.quad32 (fun
(i:(va_int_range 0 5)) -> Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE
i)) in let (plains:(six_of Vale.X64.Decls.quad32)) = make_six_of #Vale.X64.Decls.quad32 (fun
(i:(va_int_range 0 5)) -> Vale.X64.Decls.buffer128_read in_b (count `op_Multiply` 6 + i)
(va_get_mem_heaplet 6 va_s)) in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 1108 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_final alg iv_b scratch_b key_words round_keys keys_b (Vale.AES.GCTR.inc32lite
ctr_BE 6) init ctrs plains (Vale.X64.Decls.buffer128_read in0_b ((count - 1) `op_Multiply` 6 +
0) (va_get_mem_heaplet 6 va_s))) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 1111 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Sub64 (va_op_dst_opr64_reg64 rRdx) (va_const_opr64 6)) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 1112 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Add64 (va_op_dst_opr64_reg64 rR14) (va_const_opr64 96)) (fun (va_s:va_state) _ -> let
(y_new:quad32) = Vale.AES.GHash.ghash_incremental0 h_LE y_prev data in let (mem_snap:vale_heap)
= va_get_mem_heaplet 6 va_s in va_qAssertSquash va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 1116 column 36 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(count - 2 >= 0 /\ (fun a_1906 (s_1907:(FStar.Seq.Base.seq a_1906)) (i_1908:Prims.nat)
(j_1909:Prims.nat) -> let (j_1869:Prims.nat) = j_1909 in Prims.b2t (Prims.op_AmpAmp
(Prims.op_LessThanOrEqual i_1908 j_1869) (Prims.op_LessThanOrEqual j_1869
(FStar.Seq.Base.length #a_1906 s_1907)))) Vale.X64.Decls.quad32 (Vale.X64.Decls.s128
(va_get_mem_heaplet 6 va_s) in0_b) 0 ((count - 2) `op_Multiply` 6)) (fun _ -> let
(va_arg93:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = data in let
(va_arg92:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = FStar.Seq.Base.slice
#Vale.X64.Decls.quad32 (Vale.X64.Decls.s128 (va_get_mem_heaplet 6 va_s) in0_b) 0 ((count - 2)
`op_Multiply` 6) in let (va_arg91:Vale.Def.Types_s.quad32) = y_new in let
(va_arg90:Vale.Def.Types_s.quad32) = y_orig in let (va_arg89:Vale.Def.Types_s.quad32) = h_LE in
va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 1116 column 36 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.GHash.lemma_ghash_incremental0_append va_arg89 va_arg90 y_prev
va_arg91 va_arg92 va_arg93) (va_qAssertSquash va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 1117 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(count - 2 >= 0 /\ (fun a_1906 (s_1907:(FStar.Seq.Base.seq a_1906)) (i_1908:Prims.nat)
(j_1909:Prims.nat) -> let (j_1869:Prims.nat) = j_1909 in Prims.b2t (Prims.op_AmpAmp
(Prims.op_LessThanOrEqual i_1908 j_1869) (Prims.op_LessThanOrEqual j_1869
(FStar.Seq.Base.length #a_1906 s_1907)))) Vale.X64.Decls.quad32 (Vale.X64.Decls.s128
(va_get_mem_heaplet 6 va_s) in0_b) 0 ((count - 2) `op_Multiply` 6)) (fun _ -> va_qAssert
va_range1
"***** PRECONDITION NOT MET AT line 1117 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(y_new == Vale.AES.GHash.ghash_incremental0 h_LE y_orig (FStar.Seq.Base.append
#Vale.X64.Decls.quad32 (FStar.Seq.Base.slice #Vale.X64.Decls.quad32 (Vale.X64.Decls.s128
(va_get_mem_heaplet 6 va_s) in0_b) 0 ((count - 2) `op_Multiply` 6)) data)) (va_qAssertSquash
va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 1118 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(count - 2 >= 0 /\ (fun a_1906 (s_1907:(FStar.Seq.Base.seq a_1906)) (i_1908:Prims.nat)
(j_1909:Prims.nat) -> let (j_1869:Prims.nat) = j_1909 in Prims.b2t (Prims.op_AmpAmp
(Prims.op_LessThanOrEqual i_1908 j_1869) (Prims.op_LessThanOrEqual j_1869
(FStar.Seq.Base.length #a_1906 s_1907)))) Vale.X64.Decls.quad32 (Vale.X64.Decls.s128
(va_get_mem_heaplet 6 va_s) in0_b) 0 ((count - 2) `op_Multiply` 6) /\ count - 1 >= 0 /\ (fun
a_1906 (s_1907:(FStar.Seq.Base.seq a_1906)) (i_1908:Prims.nat) (j_1909:Prims.nat) -> let
(j_1869:Prims.nat) = j_1909 in Prims.b2t (Prims.op_AmpAmp (Prims.op_LessThanOrEqual i_1908
j_1869) (Prims.op_LessThanOrEqual j_1869 (FStar.Seq.Base.length #a_1906 s_1907))))
Vale.X64.Decls.quad32 (Vale.X64.Decls.s128 (va_get_mem_heaplet 6 va_s) in0_b) 0 ((count - 1)
`op_Multiply` 6)) (fun _ -> va_qAssert va_range1
"***** PRECONDITION NOT MET AT line 1118 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(FStar.Seq.Base.equal #Vale.X64.Decls.quad32 (FStar.Seq.Base.append #Vale.X64.Decls.quad32
(FStar.Seq.Base.slice #Vale.X64.Decls.quad32 (Vale.X64.Decls.s128 (va_get_mem_heaplet 6 va_s)
in0_b) 0 ((count - 2) `op_Multiply` 6)) data) (FStar.Seq.Base.slice #Vale.X64.Decls.quad32
(Vale.X64.Decls.s128 (va_get_mem_heaplet 6 va_s) in0_b) 0 ((count - 1) `op_Multiply` 6)))
(va_qAssertSquash va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 1121 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(count - 1 >= 0 /\ (fun a_1906 (s_1907:(FStar.Seq.Base.seq a_1906)) (i_1908:Prims.nat)
(j_1909:Prims.nat) -> let (j_1869:Prims.nat) = j_1909 in Prims.b2t (Prims.op_AmpAmp
(Prims.op_LessThanOrEqual i_1908 j_1869) (Prims.op_LessThanOrEqual j_1869
(FStar.Seq.Base.length #a_1906 s_1907)))) Vale.X64.Decls.quad32 (Vale.X64.Decls.s128
(va_get_mem_heaplet 6 va_s) in0_b) 0 ((count - 1) `op_Multiply` 6)) (fun _ -> va_qAssert
va_range1
"***** PRECONDITION NOT MET AT line 1121 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(y_new == Vale.AES.GHash.ghash_incremental0 h_LE y_orig (FStar.Seq.Base.slice
#Vale.X64.Decls.quad32 (Vale.X64.Decls.s128 (va_get_mem_heaplet 6 va_s) in0_b) 0 ((count - 1)
`op_Multiply` 6))) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 1123 column 8 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_qIf va_mods (Cmp_gt (va_op_cmp_reg64 rRdx) (va_const_cmp 0)) (qblock va_mods (fun
(va_s:va_state) -> va_QBind va_range1
"***** PRECONDITION NOT MET AT line 1125 column 27 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_save_output count out_b) (fun (va_s:va_state) _ -> va_qAssertSquash va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 1126 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(count - 1 >= 0 /\ (fun a_1906 (s_1907:(FStar.Seq.Base.seq a_1906)) (i_1908:Prims.nat)
(j_1909:Prims.nat) -> let (j_1869:Prims.nat) = j_1909 in Prims.b2t (Prims.op_AmpAmp
(Prims.op_LessThanOrEqual i_1908 j_1869) (Prims.op_LessThanOrEqual j_1869
(FStar.Seq.Base.length #a_1906 s_1907)))) Vale.X64.Decls.quad32 (Vale.X64.Decls.s128
(va_get_mem_heaplet 6 va_s) out_b) 0 ((count - 1) `op_Multiply` 6) /\ count - 1 >= 0 /\ (fun
a_1906 (s_1907:(FStar.Seq.Base.seq a_1906)) (i_1908:Prims.nat) (j_1909:Prims.nat) -> let
(j_1869:Prims.nat) = j_1909 in Prims.b2t (Prims.op_AmpAmp (Prims.op_LessThanOrEqual i_1908
j_1869) (Prims.op_LessThanOrEqual j_1869 (FStar.Seq.Base.length #a_1906 s_1907))))
Vale.X64.Decls.quad32 (Vale.X64.Decls.s128 mem_snap out_b) 0 ((count - 1) `op_Multiply` 6))
(fun _ -> va_qAssert va_range1
"***** PRECONDITION NOT MET AT line 1126 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(FStar.Seq.Base.equal #Vale.X64.Decls.quad32 (FStar.Seq.Base.slice #Vale.X64.Decls.quad32
(Vale.X64.Decls.s128 (va_get_mem_heaplet 6 va_s) out_b) 0 ((count - 1) `op_Multiply` 6))
(FStar.Seq.Base.slice #Vale.X64.Decls.quad32 (Vale.X64.Decls.s128 mem_snap out_b) 0 ((count -
1) `op_Multiply` 6))) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 1129 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 3) (va_op_xmm_xmm 7) (va_op_reg_opr64_reg64
rRbp) 32 Secret scratch_b 2) (fun (va_s:va_state) _ -> let (plain:(FStar.Seq.Base.seq
Vale.X64.Decls.quad32)) = Vale.X64.Decls.s128 (va_get_mem_heaplet 6 va_old_s) in_b in let
(cipher:(FStar.Seq.Base.seq Vale.X64.Decls.quad32)) = Vale.X64.Decls.s128 (va_get_mem_heaplet 6
va_s) out_b in let (bound:(va_int_at_least 0)) = count `op_Multiply` 6 in va_qAssertSquash
va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 1134 column 44 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(bound >= 0 /\ bound <= 4294967295) (fun _ -> let (va_arg88:Vale.Def.Types_s.quad32) =
ctr_BE_orig in let (va_arg87:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) = key_words in let
(va_arg86:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = cipher in let
(va_arg85:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = Vale.X64.Decls.buffer128_as_seq
(va_get_mem_heaplet 6 va_old_s) out_b in let (va_arg84:(FStar.Seq.Base.seq
Vale.Def.Types_s.quad32)) = plain_quads in let (va_arg83:(FStar.Seq.Base.seq
Vale.Def.Types_s.quad32)) = plain_quads in let (va_arg82:Vale.Def.Types_s.nat32) = bound in let
(va_arg81:Vale.AES.AES_common_s.algorithm) = alg in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 1134 column 44 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.GCTR.gctr_partial_opaque_ignores_postfix va_arg81 va_arg82 va_arg83
va_arg84 va_arg85 va_arg86 va_arg87 va_arg88) (let (va_arg80:Vale.Def.Types_s.quad32) =
ctr_BE_orig in let (va_arg79:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) = key_words in let
(va_arg78:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = cipher in let
(va_arg77:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = plain_quads in let
(va_arg76:Prims.nat) = bound in let (va_arg75:Vale.AES.AES_common_s.algorithm) = alg in
va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 1137 column 29 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.GCTR.gctr_partial_extend6 va_arg75 va_arg76 va_arg77 va_arg78
va_arg79 va_arg80) (let (va_arg74:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(va_get_xmm 4 va_s) in let (va_arg73:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.X64.Decls.buffer128_read scratch_b 1 (va_get_mem_heaplet 3 va_s)) in let
(va_arg72:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_get_xmm 8 va_s) in
va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 1138 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.GHash.lemma_add_manip va_arg72 va_arg73 va_arg74) (va_qAssert
va_range1
"***** PRECONDITION NOT MET AT line 1139 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(y_new == Vale.Def.Types_s.reverse_bytes_quad32 (Vale.Math.Poly2.Bits_s.to_quad32
(Vale.Math.Poly2.Bits_s.of_quad32 (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.AES.GHash.ghash_incremental h_LE y_prev data))))) (va_QEmpty (())))))))))))) (qblock
va_mods (fun (va_s:va_state) -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 1143 column 33 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mem128_lemma (va_op_heaplet_mem_heaplet 3) (va_op_reg64_reg64 rRbp) 16 Secret
scratch_b 1) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 1143 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPolyAdd (va_op_xmm_xmm 8) (va_op_xmm_xmm 8) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 3) (va_op_reg64_reg64 rRbp) 16 Secret)) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 1144 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPolyAdd (va_op_xmm_xmm 8) (va_op_xmm_xmm 8) (va_op_opr128_xmm 4)) (fun
(va_s:va_state) _ -> va_qAssert va_range1
"***** PRECONDITION NOT MET AT line 1145 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.Math.Poly2.Bits_s.of_quad32 (va_get_xmm 8 va_s) == Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GHash.ghash_incremental h_LE y_prev data)))
(va_qAssert va_range1
"***** PRECONDITION NOT MET AT line 1146 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.Math.Poly2.Bits_s.to_quad32 (Vale.Math.Poly2.Bits_s.of_quad32 (va_get_xmm 8 va_s)) ==
Vale.Math.Poly2.Bits_s.to_quad32 (Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GHash.ghash_incremental h_LE y_prev data))))
(va_qAssert va_range1
"***** PRECONDITION NOT MET AT line 1147 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_xmm 8 va_s == Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GHash.ghash_incremental
h_LE y_prev data)) (va_QEmpty (())))))))))) (fun (va_s:va_state) va_g -> va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 1149 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.GCTR.gctr_registers_reveal ()) (va_QEmpty ((y_new))))))))))))))))))))) | {
"file_name": "obj/Vale.AES.X64.AESopt.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 100,
"end_line": 2432,
"start_col": 0,
"start_line": 2253
} | module Vale.AES.X64.AESopt
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.AES.AES_helpers
//open Vale.Poly1305.Math // For lemma_poly_bits64()
open Vale.AES.GCM_helpers
open Vale.AES.GCTR_s
open Vale.AES.GCTR
open Vale.Arch.TypesNative
open Vale.X64.CPU_Features_s
open Vale.Math.Poly2_s
open Vale.AES.GF128_s
open Vale.AES.GF128
open Vale.AES.GHash
open Vale.AES.X64.PolyOps
open Vale.AES.X64.AESopt2
open Vale.AES.X64.AESGCM_expected_code
open Vale.Transformers.Transform
open FStar.Mul
let add = Vale.Math.Poly2_s.add
#reset-options "--z3rlimit 30"
//-- finish_aes_encrypt_le
val finish_aes_encrypt_le : alg:algorithm -> input_LE:quad32 -> key:(seq nat32)
-> Lemma
(requires (Vale.AES.AES_s.is_aes_key_LE alg key))
(ensures (Vale.AES.AES_s.aes_encrypt_LE alg key input_LE == Vale.AES.AES_s.eval_cipher alg
input_LE (Vale.AES.AES_s.key_to_round_keys_LE alg key)))
let finish_aes_encrypt_le alg input_LE key =
Vale.AES.AES_s.aes_encrypt_LE_reveal ();
Vale.AES.AES_s.eval_cipher_reveal ();
()
//--
//-- Load_two_lsb
[@ "opaque_to_smt"]
let va_code_Load_two_lsb dst =
(va_Block (va_CCons (va_code_ZeroXmm dst) (va_CCons (va_code_PinsrqImm dst 2 0
(va_op_reg_opr64_reg64 rR11)) (va_CNil ()))))
[@ "opaque_to_smt"]
let va_codegen_success_Load_two_lsb dst =
(va_pbool_and (va_codegen_success_ZeroXmm dst) (va_pbool_and (va_codegen_success_PinsrqImm dst 2
0 (va_op_reg_opr64_reg64 rR11)) (va_ttrue ())))
[@"opaque_to_smt"]
let va_lemma_Load_two_lsb va_b0 va_s0 dst =
va_reveal_opaque (`%va_code_Load_two_lsb) (va_code_Load_two_lsb dst);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let (va_s3, va_fc3) = va_lemma_ZeroXmm (va_hd va_b1) va_s0 dst in
let va_b3 = va_tl va_b1 in
Vale.Arch.Types.lemma_insert_nat64_nat32s (va_eval_xmm va_s3 dst) 2 0;
assert (Vale.Arch.Types.two_to_nat32 (Vale.Def.Words_s.Mktwo #Vale.Def.Words_s.nat32 2 0) == 2);
let (va_s6, va_fc6) = va_lemma_PinsrqImm (va_hd va_b3) va_s3 dst 2 0 (va_op_reg_opr64_reg64 rR11)
in
let va_b6 = va_tl va_b3 in
let (va_sM, va_f6) = va_lemma_empty_total va_s6 va_b6 in
let va_f3 = va_lemma_merge_total va_b3 va_s3 va_fc6 va_s6 va_f6 va_sM in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc3 va_s3 va_f3 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Load_two_lsb dst va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Load_two_lsb (va_code_Load_two_lsb dst) va_s0 dst in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_reg64 rR11 va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0)))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_reg64 rR11; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Load_0xc2_msb
val va_code_Load_0xc2_msb : dst:va_operand_xmm -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Load_0xc2_msb dst =
(va_Block (va_CCons (va_code_ZeroXmm dst) (va_CCons (va_code_PinsrqImm dst 13979173243358019584 1
(va_op_reg_opr64_reg64 rR11)) (va_CNil ()))))
val va_codegen_success_Load_0xc2_msb : dst:va_operand_xmm -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Load_0xc2_msb dst =
(va_pbool_and (va_codegen_success_ZeroXmm dst) (va_pbool_and (va_codegen_success_PinsrqImm dst
13979173243358019584 1 (va_op_reg_opr64_reg64 rR11)) (va_ttrue ())))
val va_lemma_Load_0xc2_msb : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load_0xc2_msb dst) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 3254779904 /\
va_state_eq va_sM (va_update_flags va_sM (va_update_reg64 rR11 va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0))))))
[@"opaque_to_smt"]
let va_lemma_Load_0xc2_msb va_b0 va_s0 dst =
va_reveal_opaque (`%va_code_Load_0xc2_msb) (va_code_Load_0xc2_msb dst);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let (va_s3, va_fc3) = va_lemma_ZeroXmm (va_hd va_b1) va_s0 dst in
let va_b3 = va_tl va_b1 in
assert (Vale.Arch.Types.two_to_nat32 (Vale.Def.Words_s.Mktwo #Vale.Def.Words_s.nat32 0
3254779904) == 13979173243358019584);
Vale.Arch.Types.lemma_insert_nat64_nat32s (va_eval_xmm va_s3 dst) 0 3254779904;
let (va_s6, va_fc6) = va_lemma_PinsrqImm (va_hd va_b3) va_s3 dst 13979173243358019584 1
(va_op_reg_opr64_reg64 rR11) in
let va_b6 = va_tl va_b3 in
let (va_sM, va_f6) = va_lemma_empty_total va_s6 va_b6 in
let va_f3 = va_lemma_merge_total va_b3 va_s3 va_fc6 va_s6 va_f6 va_sM in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc3 va_s3 va_f3 va_sM in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Load_0xc2_msb (dst:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) :
Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall (va_x_dst:va_value_xmm)
(va_x_r11:nat64) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_reg64
rR11 va_x_r11 (va_upd_operand_xmm dst va_x_dst va_s0)) in va_get_ok va_sM /\ va_eval_xmm va_sM
dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 3254779904 ==> va_k va_sM (())))
val va_wpProof_Load_0xc2_msb : dst:va_operand_xmm -> va_s0:va_state -> va_k:(va_state -> unit ->
Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load_0xc2_msb dst va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Load_0xc2_msb dst) ([va_Mod_flags;
va_Mod_reg64 rR11; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Load_0xc2_msb dst va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Load_0xc2_msb (va_code_Load_0xc2_msb dst) va_s0 dst in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_reg64 rR11 va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0)))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_reg64 rR11; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Load_0xc2_msb (dst:va_operand_xmm) : (va_quickCode unit (va_code_Load_0xc2_msb dst)) =
(va_QProc (va_code_Load_0xc2_msb dst) ([va_Mod_flags; va_Mod_reg64 rR11; va_mod_xmm dst])
(va_wp_Load_0xc2_msb dst) (va_wpProof_Load_0xc2_msb dst))
//--
//-- Load_one_lsb
[@ "opaque_to_smt"]
let va_code_Load_one_lsb dst =
(va_Block (va_CCons (va_code_ZeroXmm dst) (va_CCons (va_code_PinsrqImm dst 1 0
(va_op_reg_opr64_reg64 rR11)) (va_CNil ()))))
[@ "opaque_to_smt"]
let va_codegen_success_Load_one_lsb dst =
(va_pbool_and (va_codegen_success_ZeroXmm dst) (va_pbool_and (va_codegen_success_PinsrqImm dst 1
0 (va_op_reg_opr64_reg64 rR11)) (va_ttrue ())))
[@"opaque_to_smt"]
let va_lemma_Load_one_lsb va_b0 va_s0 dst =
va_reveal_opaque (`%va_code_Load_one_lsb) (va_code_Load_one_lsb dst);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let (va_s3, va_fc3) = va_lemma_ZeroXmm (va_hd va_b1) va_s0 dst in
let va_b3 = va_tl va_b1 in
Vale.Arch.Types.lemma_insert_nat64_nat32s (va_eval_xmm va_s3 dst) 1 0;
assert (Vale.Arch.Types.two_to_nat32 (Vale.Def.Words_s.Mktwo #Vale.Def.Words_s.nat32 1 0) == 1);
let (va_s6, va_fc6) = va_lemma_PinsrqImm (va_hd va_b3) va_s3 dst 1 0 (va_op_reg_opr64_reg64 rR11)
in
let va_b6 = va_tl va_b3 in
let (va_sM, va_f6) = va_lemma_empty_total va_s6 va_b6 in
let va_f3 = va_lemma_merge_total va_b3 va_s3 va_fc6 va_s6 va_f6 va_sM in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc3 va_s3 va_f3 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Load_one_lsb dst va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Load_one_lsb (va_code_Load_one_lsb dst) va_s0 dst in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_reg64 rR11 va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0)))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_reg64 rR11; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Handle_ctr32
val va_code_Handle_ctr32 : va_dummy:unit -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_Handle_ctr32 () =
(va_Block (va_CCons (va_code_InitPshufbMask (va_op_xmm_xmm 0) (va_op_reg_opr64_reg64 rR11))
(va_CCons (va_code_VPshufb (va_op_xmm_xmm 6) (va_op_xmm_xmm 1) (va_op_xmm_xmm 0)) (va_CCons
(va_code_Load_one_lsb (va_op_xmm_xmm 5)) (va_CCons (va_code_VPaddd (va_op_xmm_xmm 10)
(va_op_xmm_xmm 6) (va_op_xmm_xmm 5)) (va_CCons (va_code_Load_two_lsb (va_op_xmm_xmm 5))
(va_CCons (va_code_VPaddd (va_op_xmm_xmm 11) (va_op_xmm_xmm 6) (va_op_xmm_xmm 5)) (va_CCons
(va_code_VPaddd (va_op_xmm_xmm 12) (va_op_xmm_xmm 10) (va_op_xmm_xmm 5)) (va_CCons
(va_code_VPshufb (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_xmm_xmm 0)) (va_CCons
(va_code_VPaddd (va_op_xmm_xmm 13) (va_op_xmm_xmm 11) (va_op_xmm_xmm 5)) (va_CCons
(va_code_VPshufb (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_xmm_xmm 0)) (va_CCons
(va_code_VPxor (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_opr128_xmm 15)) (va_CCons
(va_code_VPaddd (va_op_xmm_xmm 14) (va_op_xmm_xmm 12) (va_op_xmm_xmm 5)) (va_CCons
(va_code_VPshufb (va_op_xmm_xmm 12) (va_op_xmm_xmm 12) (va_op_xmm_xmm 0)) (va_CCons
(va_code_VPxor (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_opr128_xmm 15)) (va_CCons
(va_code_VPaddd (va_op_xmm_xmm 1) (va_op_xmm_xmm 13) (va_op_xmm_xmm 5)) (va_CCons
(va_code_VPshufb (va_op_xmm_xmm 13) (va_op_xmm_xmm 13) (va_op_xmm_xmm 0)) (va_CCons
(va_code_VPshufb (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_xmm_xmm 0)) (va_CCons
(va_code_VPshufb (va_op_xmm_xmm 1) (va_op_xmm_xmm 1) (va_op_xmm_xmm 0)) (va_CNil
()))))))))))))))))))))
val va_codegen_success_Handle_ctr32 : va_dummy:unit -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_Handle_ctr32 () =
(va_pbool_and (va_codegen_success_InitPshufbMask (va_op_xmm_xmm 0) (va_op_reg_opr64_reg64 rR11))
(va_pbool_and (va_codegen_success_VPshufb (va_op_xmm_xmm 6) (va_op_xmm_xmm 1) (va_op_xmm_xmm
0)) (va_pbool_and (va_codegen_success_Load_one_lsb (va_op_xmm_xmm 5)) (va_pbool_and
(va_codegen_success_VPaddd (va_op_xmm_xmm 10) (va_op_xmm_xmm 6) (va_op_xmm_xmm 5))
(va_pbool_and (va_codegen_success_Load_two_lsb (va_op_xmm_xmm 5)) (va_pbool_and
(va_codegen_success_VPaddd (va_op_xmm_xmm 11) (va_op_xmm_xmm 6) (va_op_xmm_xmm 5))
(va_pbool_and (va_codegen_success_VPaddd (va_op_xmm_xmm 12) (va_op_xmm_xmm 10) (va_op_xmm_xmm
5)) (va_pbool_and (va_codegen_success_VPshufb (va_op_xmm_xmm 10) (va_op_xmm_xmm 10)
(va_op_xmm_xmm 0)) (va_pbool_and (va_codegen_success_VPaddd (va_op_xmm_xmm 13) (va_op_xmm_xmm
11) (va_op_xmm_xmm 5)) (va_pbool_and (va_codegen_success_VPshufb (va_op_xmm_xmm 11)
(va_op_xmm_xmm 11) (va_op_xmm_xmm 0)) (va_pbool_and (va_codegen_success_VPxor (va_op_xmm_xmm
10) (va_op_xmm_xmm 10) (va_op_opr128_xmm 15)) (va_pbool_and (va_codegen_success_VPaddd
(va_op_xmm_xmm 14) (va_op_xmm_xmm 12) (va_op_xmm_xmm 5)) (va_pbool_and
(va_codegen_success_VPshufb (va_op_xmm_xmm 12) (va_op_xmm_xmm 12) (va_op_xmm_xmm 0))
(va_pbool_and (va_codegen_success_VPxor (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_opr128_xmm
15)) (va_pbool_and (va_codegen_success_VPaddd (va_op_xmm_xmm 1) (va_op_xmm_xmm 13)
(va_op_xmm_xmm 5)) (va_pbool_and (va_codegen_success_VPshufb (va_op_xmm_xmm 13) (va_op_xmm_xmm
13) (va_op_xmm_xmm 0)) (va_pbool_and (va_codegen_success_VPshufb (va_op_xmm_xmm 14)
(va_op_xmm_xmm 14) (va_op_xmm_xmm 0)) (va_pbool_and (va_codegen_success_VPshufb (va_op_xmm_xmm
1) (va_op_xmm_xmm 1) (va_op_xmm_xmm 0)) (va_ttrue ())))))))))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_Handle_ctr32 (va_mods:va_mods_t) (ctr_BE:quad32) : (va_quickCode unit
(va_code_Handle_ctr32 ())) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 256 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_InitPshufbMask (va_op_xmm_xmm 0) (va_op_reg_opr64_reg64 rR11)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 257 column 12 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPshufb (va_op_xmm_xmm 6) (va_op_xmm_xmm 1) (va_op_xmm_xmm 0)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 261 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load_one_lsb (va_op_xmm_xmm 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 262 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 10) (va_op_xmm_xmm 6) (va_op_xmm_xmm 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 263 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load_two_lsb (va_op_xmm_xmm 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 264 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 11) (va_op_xmm_xmm 6) (va_op_xmm_xmm 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 265 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 12) (va_op_xmm_xmm 10) (va_op_xmm_xmm 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 266 column 12 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPshufb (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_xmm_xmm 0)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 267 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 13) (va_op_xmm_xmm 11) (va_op_xmm_xmm 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 268 column 12 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPshufb (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_xmm_xmm 0)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 269 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_opr128_xmm 15)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 270 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 14) (va_op_xmm_xmm 12) (va_op_xmm_xmm 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 271 column 12 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPshufb (va_op_xmm_xmm 12) (va_op_xmm_xmm 12) (va_op_xmm_xmm 0)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 272 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_opr128_xmm 15)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 273 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 1) (va_op_xmm_xmm 13) (va_op_xmm_xmm 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 274 column 12 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPshufb (va_op_xmm_xmm 13) (va_op_xmm_xmm 13) (va_op_xmm_xmm 0)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 275 column 12 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPshufb (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_xmm_xmm 0)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 276 column 12 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPshufb (va_op_xmm_xmm 1) (va_op_xmm_xmm 1) (va_op_xmm_xmm 0)) (va_QEmpty
(())))))))))))))))))))))
val va_lemma_Handle_ctr32 : va_b0:va_code -> va_s0:va_state -> ctr_BE:quad32
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Handle_ctr32 ()) va_s0 /\ va_get_ok va_s0 /\
(avx_enabled /\ sse_enabled /\ va_get_xmm 1 va_s0 == Vale.Def.Types_s.reverse_bytes_quad32
ctr_BE)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM, va_get_xmm 13 va_sM, va_get_xmm
14 va_sM, va_get_xmm 1 va_sM) == xor_reverse_inc32lite_6 2 1 ctr_BE (va_get_xmm 15 va_sM) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 14 va_sM (va_update_xmm 13 va_sM
(va_update_xmm 12 va_sM (va_update_xmm 11 va_sM (va_update_xmm 10 va_sM (va_update_xmm 6 va_sM
(va_update_xmm 5 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_xmm 0 va_sM
(va_update_reg64 rR11 va_sM (va_update_ok va_sM va_s0)))))))))))))))
[@"opaque_to_smt"]
let va_lemma_Handle_ctr32 va_b0 va_s0 ctr_BE =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm
11; va_Mod_xmm 10; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0;
va_Mod_reg64 rR11; va_Mod_ok] in
let va_qc = va_qcode_Handle_ctr32 va_mods ctr_BE in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_Handle_ctr32 ()) va_qc va_s0 (fun va_s0
va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 234 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 254 column 107 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM, va_get_xmm 13 va_sM,
va_get_xmm 14 va_sM, va_get_xmm 1 va_sM) == xor_reverse_inc32lite_6 2 1 ctr_BE (va_get_xmm 15
va_sM))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11;
va_Mod_xmm 10; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0;
va_Mod_reg64 rR11; va_Mod_ok]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Handle_ctr32 (ctr_BE:quad32) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (avx_enabled /\ sse_enabled /\ va_get_xmm 1 va_s0 ==
Vale.Def.Types_s.reverse_bytes_quad32 ctr_BE) /\ (forall (va_x_r11:nat64) (va_x_xmm0:quad32)
(va_x_xmm1:quad32) (va_x_xmm2:quad32) (va_x_xmm5:quad32) (va_x_xmm6:quad32) (va_x_xmm10:quad32)
(va_x_xmm11:quad32) (va_x_xmm12:quad32) (va_x_xmm13:quad32) (va_x_xmm14:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 14 va_x_xmm14
(va_upd_xmm 13 va_x_xmm13 (va_upd_xmm 12 va_x_xmm12 (va_upd_xmm 11 va_x_xmm11 (va_upd_xmm 10
va_x_xmm10 (va_upd_xmm 6 va_x_xmm6 (va_upd_xmm 5 va_x_xmm5 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm
1 va_x_xmm1 (va_upd_xmm 0 va_x_xmm0 (va_upd_reg64 rR11 va_x_r11 va_s0))))))))))) in va_get_ok
va_sM /\ (va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM, va_get_xmm 13 va_sM,
va_get_xmm 14 va_sM, va_get_xmm 1 va_sM) == xor_reverse_inc32lite_6 2 1 ctr_BE (va_get_xmm 15
va_sM) ==> va_k va_sM (())))
val va_wpProof_Handle_ctr32 : ctr_BE:quad32 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Handle_ctr32 ctr_BE va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Handle_ctr32 ()) ([va_Mod_flags;
va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 6;
va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_reg64 rR11]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Handle_ctr32 ctr_BE va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Handle_ctr32 (va_code_Handle_ctr32 ()) va_s0 ctr_BE in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 14 va_sM (va_update_xmm 13 va_sM
(va_update_xmm 12 va_sM (va_update_xmm 11 va_sM (va_update_xmm 10 va_sM (va_update_xmm 6 va_sM
(va_update_xmm 5 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_xmm 0 va_sM
(va_update_reg64 rR11 va_sM (va_update_ok va_sM va_s0))))))))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11;
va_Mod_xmm 10; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0;
va_Mod_reg64 rR11]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Handle_ctr32 (ctr_BE:quad32) : (va_quickCode unit (va_code_Handle_ctr32 ())) =
(va_QProc (va_code_Handle_ctr32 ()) ([va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12;
va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_xmm 0; va_Mod_reg64 rR11]) (va_wp_Handle_ctr32 ctr_BE) (va_wpProof_Handle_ctr32 ctr_BE))
//--
//-- Loop6x_ctr_update
val va_code_Loop6x_ctr_update : alg:algorithm -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_Loop6x_ctr_update alg =
(va_Block (va_CCons (va_code_Add64 (va_op_dst_opr64_reg64 rRbx) (va_const_opr64 6)) (va_CCons
(va_IfElse (va_cmp_ge (va_op_cmp_reg64 rRbx) (va_const_cmp 256)) (va_Block (va_CCons
(va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 3) (va_op_reg_opr64_reg64
rR9) (0 - 32) Secret) (va_CCons (va_code_Handle_ctr32 ()) (va_CCons (va_code_Sub64
(va_op_dst_opr64_reg64 rRbx) (va_const_opr64 256)) (va_CNil ()))))) (va_Block (va_CCons
(va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 3) (va_op_reg_opr64_reg64
rR9) (0 - 32) Secret) (va_CCons (va_code_VPaddd (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)
(va_op_xmm_xmm 14)) (va_CCons (va_code_VPxor (va_op_xmm_xmm 10) (va_op_xmm_xmm 10)
(va_op_opr128_xmm 15)) (va_CCons (va_code_VPxor (va_op_xmm_xmm 11) (va_op_xmm_xmm 11)
(va_op_opr128_xmm 15)) (va_CNil ()))))))) (va_CNil ()))))
val va_codegen_success_Loop6x_ctr_update : alg:algorithm -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_Loop6x_ctr_update alg =
(va_pbool_and (va_codegen_success_Add64 (va_op_dst_opr64_reg64 rRbx) (va_const_opr64 6))
(va_pbool_and (va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 3) (va_op_reg_opr64_reg64 rR9) (0 - 32) Secret) (va_pbool_and
(va_codegen_success_Handle_ctr32 ()) (va_pbool_and (va_codegen_success_Sub64
(va_op_dst_opr64_reg64 rRbx) (va_const_opr64 256)) (va_pbool_and
(va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 3)
(va_op_reg_opr64_reg64 rR9) (0 - 32) Secret) (va_pbool_and (va_codegen_success_VPaddd
(va_op_xmm_xmm 1) (va_op_xmm_xmm 2) (va_op_xmm_xmm 14)) (va_pbool_and (va_codegen_success_VPxor
(va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_opr128_xmm 15)) (va_codegen_success_VPxor
(va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_opr128_xmm 15)))))))) (va_ttrue ())))
[@ "opaque_to_smt" va_qattr]
let va_qcode_Loop6x_ctr_update (va_mods:va_mods_t) (alg:algorithm) (h_LE:quad32) (key_words:(seq
nat32)) (round_keys:(seq quad32)) (keys_b:buffer128) (hkeys_b:buffer128) (ctr_BE:quad32) :
(va_quickCode unit (va_code_Loop6x_ctr_update alg)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in let
(h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in va_QBind va_range1
"***** PRECONDITION NOT MET AT line 339 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Add64 (va_op_dst_opr64_reg64 rRbx) (va_const_opr64 6)) (fun (va_s:va_state) _ ->
va_QBind va_range1
"***** PRECONDITION NOT MET AT line 340 column 8 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_qIf va_mods (Cmp_ge (va_op_cmp_reg64 rRbx) (va_const_cmp 256)) (qblock va_mods (fun
(va_s:va_state) -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 341 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 3) (va_op_reg_opr64_reg64
rR9) (0 - 32) Secret hkeys_b 0) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 342 column 21 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Handle_ctr32 ctr_BE) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 343 column 14 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Sub64 (va_op_dst_opr64_reg64 rRbx) (va_const_opr64 256)) (va_QEmpty (())))))) (qblock
va_mods (fun (va_s:va_state) -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 345 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 3) (va_op_reg_opr64_reg64
rR9) (0 - 32) Secret hkeys_b 0) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 346 column 15 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 1) (va_op_xmm_xmm 2) (va_op_xmm_xmm 14)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 347 column 14 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_opr128_xmm 15)) (va_QBind
va_range1
"***** PRECONDITION NOT MET AT line 348 column 14 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_opr128_xmm 15)) (fun
(va_s:va_state) _ -> let (va_arg36:Prims.nat) = va_get_reg64 rRbx va_old_s in let
(va_arg35:Vale.Def.Types_s.quad32) = va_get_xmm 1 va_s in let
(va_arg34:Vale.Def.Types_s.quad32) = va_get_xmm 14 va_s in let
(va_arg33:Vale.Def.Types_s.quad32) = ctr_BE in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 349 column 28 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_msb_in_bounds va_arg33 va_arg34 va_arg35 va_arg36)
(va_QEmpty (()))))))))) (fun (va_s:va_state) va_g -> va_QEmpty (())))))
val va_lemma_Loop6x_ctr_update : va_b0:va_code -> va_s0:va_state -> alg:algorithm -> h_LE:quad32 ->
key_words:(seq nat32) -> round_keys:(seq quad32) -> keys_b:buffer128 -> hkeys_b:buffer128 ->
ctr_BE:quad32
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Loop6x_ctr_update alg) va_s0 /\ va_get_ok va_s0 /\
(let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in sse_enabled /\ aes_reqs_offset alg key_words
round_keys keys_b (va_get_reg64 rRcx va_s0) (va_get_mem_heaplet 0 va_s0) (va_get_mem_layout
va_s0) /\ va_get_xmm 2 va_s0 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 16777216
/\ va_get_xmm 1 va_s0 == Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE
0) /\ va_get_reg64 rRbx va_s0 == Vale.Def.Words_s.__proj__Mkfour__item__lo0 ctr_BE `op_Modulus`
256 /\ va_get_xmm 9 va_s0 == Vale.Def.Types_s.quad32_xor (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.AES.GCTR.inc32lite ctr_BE 0)) (va_get_xmm 15 va_s0) /\ (va_get_reg64 rRbx va_s0 + 6 < 256
==> (va_get_xmm 9 va_s0, va_get_xmm 10 va_s0, va_get_xmm 11 va_s0, va_get_xmm 12 va_s0,
va_get_xmm 13 va_s0, va_get_xmm 14 va_s0) == xor_reverse_inc32lite_6 1 0 ctr_BE (va_get_xmm 15
va_s0)) /\ hkeys_b_powers hkeys_b (va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0)
(va_get_reg64 rR9 va_s0 - 32) h)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in va_get_xmm 1 va_sM ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 6) /\ (0 <= va_get_reg64
rRbx va_sM /\ va_get_reg64 rRbx va_sM < 256) /\ va_get_reg64 rRbx va_sM ==
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (Vale.AES.GCTR.inc32lite ctr_BE 6) `op_Modulus` 256
/\ (va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM,
va_get_xmm 13 va_sM, va_get_xmm 14 va_sM) == xor_reverse_inc32lite_6 3 0 ctr_BE (va_get_xmm 15
va_sM) /\ va_get_xmm 3 va_sM == Vale.X64.Decls.buffer128_read hkeys_b 0 (va_get_mem_heaplet 0
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 14 va_sM (va_update_xmm 13
va_sM (va_update_xmm 12 va_sM (va_update_xmm 11 va_sM (va_update_xmm 10 va_sM (va_update_xmm 9
va_sM (va_update_xmm 6 va_sM (va_update_xmm 5 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1
va_sM (va_update_xmm 0 va_sM (va_update_xmm 3 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rRbx va_sM (va_update_ok va_sM va_s0))))))))))))))))))
[@"opaque_to_smt"]
let va_lemma_Loop6x_ctr_update va_b0 va_s0 alg h_LE key_words round_keys keys_b hkeys_b ctr_BE =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm
11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_xmm 0; va_Mod_xmm 3; va_Mod_reg64 rR11; va_Mod_reg64 rRbx; va_Mod_ok] in
let va_qc = va_qcode_Loop6x_ctr_update va_mods alg h_LE key_words round_keys keys_b hkeys_b
ctr_BE in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_Loop6x_ctr_update alg) va_qc va_s0 (fun
va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 279 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_ok va_sM) /\ (let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in label va_range1
"***** POSTCONDITION NOT MET AT line 330 column 57 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_xmm 1 va_sM == Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE
6)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 331 column 27 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(0 <= va_get_reg64 rRbx va_sM /\ va_get_reg64 rRbx va_sM < 256) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 332 column 50 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_reg64 rRbx va_sM == Vale.Def.Words_s.__proj__Mkfour__item__lo0 (Vale.AES.GCTR.inc32lite
ctr_BE 6) `op_Modulus` 256) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 334 column 58 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM, va_get_xmm
13 va_sM, va_get_xmm 14 va_sM) == xor_reverse_inc32lite_6 3 0 ctr_BE (va_get_xmm 15 va_sM)) /\
label va_range1
"***** POSTCONDITION NOT MET AT line 335 column 50 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_xmm 3 va_sM == Vale.X64.Decls.buffer128_read hkeys_b 0 (va_get_mem_heaplet 0 va_sM))))
in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11;
va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm
0; va_Mod_xmm 3; va_Mod_reg64 rR11; va_Mod_reg64 rRbx; va_Mod_ok]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Loop6x_ctr_update (alg:algorithm) (h_LE:quad32) (key_words:(seq nat32)) (round_keys:(seq
quad32)) (keys_b:buffer128) (hkeys_b:buffer128) (ctr_BE:quad32) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in sse_enabled /\ aes_reqs_offset alg key_words
round_keys keys_b (va_get_reg64 rRcx va_s0) (va_get_mem_heaplet 0 va_s0) (va_get_mem_layout
va_s0) /\ va_get_xmm 2 va_s0 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 16777216
/\ va_get_xmm 1 va_s0 == Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE
0) /\ va_get_reg64 rRbx va_s0 == Vale.Def.Words_s.__proj__Mkfour__item__lo0 ctr_BE `op_Modulus`
256 /\ va_get_xmm 9 va_s0 == Vale.Def.Types_s.quad32_xor (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.AES.GCTR.inc32lite ctr_BE 0)) (va_get_xmm 15 va_s0) /\ (va_get_reg64 rRbx va_s0 + 6 < 256
==> (va_get_xmm 9 va_s0, va_get_xmm 10 va_s0, va_get_xmm 11 va_s0, va_get_xmm 12 va_s0,
va_get_xmm 13 va_s0, va_get_xmm 14 va_s0) == xor_reverse_inc32lite_6 1 0 ctr_BE (va_get_xmm 15
va_s0)) /\ hkeys_b_powers hkeys_b (va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0)
(va_get_reg64 rR9 va_s0 - 32) h) /\ (forall (va_x_rbx:nat64) (va_x_r11:nat64)
(va_x_xmm3:quad32) (va_x_xmm0:quad32) (va_x_xmm1:quad32) (va_x_xmm2:quad32) (va_x_xmm5:quad32)
(va_x_xmm6:quad32) (va_x_xmm9:quad32) (va_x_xmm10:quad32) (va_x_xmm11:quad32)
(va_x_xmm12:quad32) (va_x_xmm13:quad32) (va_x_xmm14:quad32) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (va_upd_xmm 14 va_x_xmm14 (va_upd_xmm 13 va_x_xmm13 (va_upd_xmm
12 va_x_xmm12 (va_upd_xmm 11 va_x_xmm11 (va_upd_xmm 10 va_x_xmm10 (va_upd_xmm 9 va_x_xmm9
(va_upd_xmm 6 va_x_xmm6 (va_upd_xmm 5 va_x_xmm5 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1
(va_upd_xmm 0 va_x_xmm0 (va_upd_xmm 3 va_x_xmm3 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rRbx
va_x_rbx va_s0)))))))))))))) in va_get_ok va_sM /\ (let (h:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in va_get_xmm 1
va_sM == Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 6) /\ (0 <=
va_get_reg64 rRbx va_sM /\ va_get_reg64 rRbx va_sM < 256) /\ va_get_reg64 rRbx va_sM ==
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (Vale.AES.GCTR.inc32lite ctr_BE 6) `op_Modulus` 256
/\ (va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM,
va_get_xmm 13 va_sM, va_get_xmm 14 va_sM) == xor_reverse_inc32lite_6 3 0 ctr_BE (va_get_xmm 15
va_sM) /\ va_get_xmm 3 va_sM == Vale.X64.Decls.buffer128_read hkeys_b 0 (va_get_mem_heaplet 0
va_sM)) ==> va_k va_sM (())))
val va_wpProof_Loop6x_ctr_update : alg:algorithm -> h_LE:quad32 -> key_words:(seq nat32) ->
round_keys:(seq quad32) -> keys_b:buffer128 -> hkeys_b:buffer128 -> ctr_BE:quad32 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Loop6x_ctr_update alg h_LE key_words round_keys keys_b
hkeys_b ctr_BE va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Loop6x_ctr_update alg) ([va_Mod_flags;
va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9;
va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_xmm 3;
va_Mod_reg64 rR11; va_Mod_reg64 rRbx]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Loop6x_ctr_update alg h_LE key_words round_keys keys_b hkeys_b ctr_BE va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Loop6x_ctr_update (va_code_Loop6x_ctr_update alg) va_s0 alg h_LE
key_words round_keys keys_b hkeys_b ctr_BE in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 14 va_sM (va_update_xmm 13 va_sM
(va_update_xmm 12 va_sM (va_update_xmm 11 va_sM (va_update_xmm 10 va_sM (va_update_xmm 9 va_sM
(va_update_xmm 6 va_sM (va_update_xmm 5 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM
(va_update_xmm 0 va_sM (va_update_xmm 3 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rRbx
va_sM (va_update_ok va_sM va_s0)))))))))))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11;
va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm
0; va_Mod_xmm 3; va_Mod_reg64 rR11; va_Mod_reg64 rRbx]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Loop6x_ctr_update (alg:algorithm) (h_LE:quad32) (key_words:(seq nat32))
(round_keys:(seq quad32)) (keys_b:buffer128) (hkeys_b:buffer128) (ctr_BE:quad32) : (va_quickCode
unit (va_code_Loop6x_ctr_update alg)) =
(va_QProc (va_code_Loop6x_ctr_update alg) ([va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13;
va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 6; va_Mod_xmm 5;
va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_xmm 3; va_Mod_reg64 rR11; va_Mod_reg64 rRbx])
(va_wp_Loop6x_ctr_update alg h_LE key_words round_keys keys_b hkeys_b ctr_BE)
(va_wpProof_Loop6x_ctr_update alg h_LE key_words round_keys keys_b hkeys_b ctr_BE))
//--
//-- Loop6x_plain
val va_code_Loop6x_plain : alg:algorithm -> rnd:nat -> rndkey:va_operand_xmm -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Loop6x_plain alg rnd rndkey =
(va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) rndkey
(va_op_reg_opr64_reg64 rRcx) (16 `op_Multiply` (rnd + 1) - 128) Secret) (va_CCons
(va_code_VAESNI_enc (va_op_xmm_xmm 9) (va_op_xmm_xmm 9) rndkey) (va_CCons (va_code_VAESNI_enc
(va_op_xmm_xmm 10) (va_op_xmm_xmm 10) rndkey) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 11)
(va_op_xmm_xmm 11) rndkey) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 12) (va_op_xmm_xmm 12)
rndkey) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 13) (va_op_xmm_xmm 13) rndkey) (va_CCons
(va_code_VAESNI_enc (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) rndkey) (va_CNil ())))))))))
val va_codegen_success_Loop6x_plain : alg:algorithm -> rnd:nat -> rndkey:va_operand_xmm -> Tot
va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Loop6x_plain alg rnd rndkey =
(va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) rndkey
(va_op_reg_opr64_reg64 rRcx) (16 `op_Multiply` (rnd + 1) - 128) Secret) (va_pbool_and
(va_codegen_success_VAESNI_enc (va_op_xmm_xmm 9) (va_op_xmm_xmm 9) rndkey) (va_pbool_and
(va_codegen_success_VAESNI_enc (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) rndkey) (va_pbool_and
(va_codegen_success_VAESNI_enc (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) rndkey) (va_pbool_and
(va_codegen_success_VAESNI_enc (va_op_xmm_xmm 12) (va_op_xmm_xmm 12) rndkey) (va_pbool_and
(va_codegen_success_VAESNI_enc (va_op_xmm_xmm 13) (va_op_xmm_xmm 13) rndkey) (va_pbool_and
(va_codegen_success_VAESNI_enc (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) rndkey) (va_ttrue
()))))))))
val va_lemma_Loop6x_plain : va_b0:va_code -> va_s0:va_state -> alg:algorithm -> rnd:nat ->
key_words:(seq nat32) -> round_keys:(seq quad32) -> keys_b:buffer128 -> init:quad32_6 ->
rndkey:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Loop6x_plain alg rnd rndkey) va_s0 /\ va_is_dst_xmm
rndkey va_s0 /\ va_get_ok va_s0 /\ (sse_enabled /\ (rndkey == 1 \/ rndkey == 2 \/ rndkey == 15)
/\ aes_reqs_offset alg key_words round_keys keys_b (va_get_reg64 rRcx va_s0)
(va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0) /\ rnd + 1 < FStar.Seq.Base.length
#quad32 round_keys /\ (va_get_xmm 9 va_s0, va_get_xmm 10 va_s0, va_get_xmm 11 va_s0, va_get_xmm
12 va_s0, va_get_xmm 13 va_s0, va_get_xmm 14 va_s0) == rounds_opaque_6 init round_keys rnd)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM, va_get_xmm
13 va_sM, va_get_xmm 14 va_sM) == rounds_opaque_6 init round_keys (rnd + 1) /\ va_state_eq
va_sM (va_update_flags va_sM (va_update_xmm 14 va_sM (va_update_xmm 13 va_sM (va_update_xmm 12
va_sM (va_update_xmm 11 va_sM (va_update_xmm 10 va_sM (va_update_xmm 9 va_sM (va_update_ok
va_sM (va_update_operand_xmm rndkey va_sM va_s0)))))))))))
[@"opaque_to_smt"]
let va_lemma_Loop6x_plain va_b0 va_s0 alg rnd key_words round_keys keys_b init rndkey =
va_reveal_opaque (`%va_code_Loop6x_plain) (va_code_Loop6x_plain alg rnd rndkey);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let (va_s9, va_fc9) = va_lemma_Load128_buffer (va_hd va_b1) va_s0 (va_op_heaplet_mem_heaplet 0)
rndkey (va_op_reg_opr64_reg64 rRcx) (16 `op_Multiply` (rnd + 1) - 128) Secret keys_b (rnd + 1)
in
let va_b9 = va_tl va_b1 in
let (va_s10, va_fc10) = va_lemma_VAESNI_enc (va_hd va_b9) va_s9 (va_op_xmm_xmm 9) (va_op_xmm_xmm
9) rndkey in
let va_b10 = va_tl va_b9 in
let (va_s11, va_fc11) = va_lemma_VAESNI_enc (va_hd va_b10) va_s10 (va_op_xmm_xmm 10)
(va_op_xmm_xmm 10) rndkey in
let va_b11 = va_tl va_b10 in
let (va_s12, va_fc12) = va_lemma_VAESNI_enc (va_hd va_b11) va_s11 (va_op_xmm_xmm 11)
(va_op_xmm_xmm 11) rndkey in
let va_b12 = va_tl va_b11 in
let (va_s13, va_fc13) = va_lemma_VAESNI_enc (va_hd va_b12) va_s12 (va_op_xmm_xmm 12)
(va_op_xmm_xmm 12) rndkey in
let va_b13 = va_tl va_b12 in
let (va_s14, va_fc14) = va_lemma_VAESNI_enc (va_hd va_b13) va_s13 (va_op_xmm_xmm 13)
(va_op_xmm_xmm 13) rndkey in
let va_b14 = va_tl va_b13 in
let (va_s15, va_fc15) = va_lemma_VAESNI_enc (va_hd va_b14) va_s14 (va_op_xmm_xmm 14)
(va_op_xmm_xmm 14) rndkey in
let va_b15 = va_tl va_b14 in
Vale.AES.AES_s.eval_rounds_reveal ();
Vale.AES.AES_helpers.commute_sub_bytes_shift_rows_forall ();
let (va_sM, va_f15) = va_lemma_empty_total va_s15 va_b15 in
let va_f14 = va_lemma_merge_total va_b14 va_s14 va_fc15 va_s15 va_f15 va_sM in
let va_f13 = va_lemma_merge_total va_b13 va_s13 va_fc14 va_s14 va_f14 va_sM in
let va_f12 = va_lemma_merge_total va_b12 va_s12 va_fc13 va_s13 va_f13 va_sM in
let va_f11 = va_lemma_merge_total va_b11 va_s11 va_fc12 va_s12 va_f12 va_sM in
let va_f10 = va_lemma_merge_total va_b10 va_s10 va_fc11 va_s11 va_f11 va_sM in
let va_f9 = va_lemma_merge_total va_b9 va_s9 va_fc10 va_s10 va_f10 va_sM in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc9 va_s9 va_f9 va_sM in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Loop6x_plain (alg:algorithm) (rnd:nat) (key_words:(seq nat32)) (round_keys:(seq quad32))
(keys_b:buffer128) (init:quad32_6) (rndkey:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm rndkey va_s0 /\ va_get_ok va_s0 /\ (sse_enabled /\ (rndkey == 1 \/ rndkey == 2 \/
rndkey == 15) /\ aes_reqs_offset alg key_words round_keys keys_b (va_get_reg64 rRcx va_s0)
(va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0) /\ rnd + 1 < FStar.Seq.Base.length
#quad32 round_keys /\ (va_get_xmm 9 va_s0, va_get_xmm 10 va_s0, va_get_xmm 11 va_s0, va_get_xmm
12 va_s0, va_get_xmm 13 va_s0, va_get_xmm 14 va_s0) == rounds_opaque_6 init round_keys rnd) /\
(forall (va_x_rndkey:va_value_xmm) (va_x_xmm9:quad32) (va_x_xmm10:quad32) (va_x_xmm11:quad32)
(va_x_xmm12:quad32) (va_x_xmm13:quad32) (va_x_xmm14:quad32) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (va_upd_xmm 14 va_x_xmm14 (va_upd_xmm 13 va_x_xmm13 (va_upd_xmm
12 va_x_xmm12 (va_upd_xmm 11 va_x_xmm11 (va_upd_xmm 10 va_x_xmm10 (va_upd_xmm 9 va_x_xmm9
(va_upd_operand_xmm rndkey va_x_rndkey va_s0))))))) in va_get_ok va_sM /\ (va_get_xmm 9 va_sM,
va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM, va_get_xmm 13 va_sM, va_get_xmm
14 va_sM) == rounds_opaque_6 init round_keys (rnd + 1) ==> va_k va_sM (())))
val va_wpProof_Loop6x_plain : alg:algorithm -> rnd:nat -> key_words:(seq nat32) -> round_keys:(seq
quad32) -> keys_b:buffer128 -> init:quad32_6 -> rndkey:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Loop6x_plain alg rnd key_words round_keys keys_b init
rndkey va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Loop6x_plain alg rnd rndkey)
([va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10;
va_Mod_xmm 9; va_mod_xmm rndkey]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Loop6x_plain alg rnd key_words round_keys keys_b init rndkey va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Loop6x_plain (va_code_Loop6x_plain alg rnd rndkey) va_s0 alg rnd
key_words round_keys keys_b init rndkey in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 14 va_sM (va_update_xmm 13 va_sM
(va_update_xmm 12 va_sM (va_update_xmm 11 va_sM (va_update_xmm 10 va_sM (va_update_xmm 9 va_sM
(va_update_ok va_sM (va_update_operand_xmm rndkey va_sM va_s0))))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11;
va_Mod_xmm 10; va_Mod_xmm 9; va_mod_xmm rndkey]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Loop6x_plain (alg:algorithm) (rnd:nat) (key_words:(seq nat32)) (round_keys:(seq
quad32)) (keys_b:buffer128) (init:quad32_6) (rndkey:va_operand_xmm) : (va_quickCode unit
(va_code_Loop6x_plain alg rnd rndkey)) =
(va_QProc (va_code_Loop6x_plain alg rnd rndkey) ([va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13;
va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_mod_xmm rndkey])
(va_wp_Loop6x_plain alg rnd key_words round_keys keys_b init rndkey) (va_wpProof_Loop6x_plain
alg rnd key_words round_keys keys_b init rndkey))
//--
//-- Loop6x_preamble
val va_code_Loop6x_preamble : alg:algorithm -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_Loop6x_preamble alg =
(va_Block (va_CCons (va_code_Loop6x_ctr_update alg) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp) (va_op_xmm_xmm 1) 128 Secret)
(va_CCons (va_code_VPxor (va_op_xmm_xmm 12) (va_op_xmm_xmm 12) (va_op_opr128_xmm 15)) (va_CCons
(va_code_VPxor (va_op_xmm_xmm 13) (va_op_xmm_xmm 13) (va_op_opr128_xmm 15)) (va_CCons
(va_code_VPxor (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_opr128_xmm 15)) (va_CNil ())))))))
val va_codegen_success_Loop6x_preamble : alg:algorithm -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_Loop6x_preamble alg =
(va_pbool_and (va_codegen_success_Loop6x_ctr_update alg) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp)
(va_op_xmm_xmm 1) 128 Secret) (va_pbool_and (va_codegen_success_VPxor (va_op_xmm_xmm 12)
(va_op_xmm_xmm 12) (va_op_opr128_xmm 15)) (va_pbool_and (va_codegen_success_VPxor
(va_op_xmm_xmm 13) (va_op_xmm_xmm 13) (va_op_opr128_xmm 15)) (va_pbool_and
(va_codegen_success_VPxor (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_opr128_xmm 15))
(va_ttrue ()))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_Loop6x_preamble (va_mods:va_mods_t) (alg:algorithm) (h_LE:quad32) (iv_b:buffer128)
(scratch_b:buffer128) (key_words:(seq nat32)) (round_keys:(seq quad32)) (keys_b:buffer128)
(hkeys_b:buffer128) (ctr_BE:quad32) : (va_quickCode unit (va_code_Loop6x_preamble alg)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in let
(h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in va_QBind va_range1
"***** PRECONDITION NOT MET AT line 477 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_ctr_update alg h_LE key_words round_keys keys_b hkeys_b ctr_BE) (fun
(va_s:va_state) _ -> let (va_arg43:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = round_keys
in let (va_arg42:Vale.Def.Types_s.quad32) = va_get_xmm 9 va_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 479 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.init_rounds_opaque va_arg42 va_arg43) (let
(va_arg41:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = round_keys in let
(va_arg40:Vale.Def.Types_s.quad32) = va_get_xmm 10 va_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 480 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.init_rounds_opaque va_arg40 va_arg41) (let
(va_arg39:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = round_keys in let
(va_arg38:Vale.Def.Types_s.quad32) = va_get_xmm 11 va_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 481 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.init_rounds_opaque va_arg38 va_arg39) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 498 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp)
(va_op_xmm_xmm 1) 128 Secret scratch_b 8) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 499 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 12) (va_op_xmm_xmm 12) (va_op_opr128_xmm 15)) (fun
(va_s:va_state) _ -> let (va_arg37:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = round_keys
in let (va_arg36:Vale.Def.Types_s.quad32) = va_get_xmm 12 va_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 499 column 54 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.init_rounds_opaque va_arg36 va_arg37) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 500 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 13) (va_op_xmm_xmm 13) (va_op_opr128_xmm 15)) (fun
(va_s:va_state) _ -> let (va_arg35:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = round_keys
in let (va_arg34:Vale.Def.Types_s.quad32) = va_get_xmm 13 va_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 500 column 54 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.init_rounds_opaque va_arg34 va_arg35) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 501 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_opr128_xmm 15)) (fun
(va_s:va_state) _ -> let (va_arg33:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = round_keys
in let (va_arg32:Vale.Def.Types_s.quad32) = va_get_xmm 14 va_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 501 column 54 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.init_rounds_opaque va_arg32 va_arg33) (va_QEmpty
(()))))))))))))))
val va_lemma_Loop6x_preamble : va_b0:va_code -> va_s0:va_state -> alg:algorithm -> h_LE:quad32 ->
iv_b:buffer128 -> scratch_b:buffer128 -> key_words:(seq nat32) -> round_keys:(seq quad32) ->
keys_b:buffer128 -> hkeys_b:buffer128 -> ctr_BE:quad32
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Loop6x_preamble alg) va_s0 /\ va_get_ok va_s0 /\ (let
(h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in sse_enabled /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 3 va_s0) (va_get_reg64 rRbp va_s0) scratch_b 9 (va_get_mem_layout va_s0)
Secret /\ aes_reqs_offset alg key_words round_keys keys_b (va_get_reg64 rRcx va_s0)
(va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0) /\ va_get_xmm 15 va_s0 ==
FStar.Seq.Base.index #quad32 round_keys 0 /\ va_get_xmm 2 va_s0 == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 0 0 0 16777216 /\ va_get_xmm 1 va_s0 ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 0) /\ va_get_reg64 rRbx
va_s0 == Vale.Def.Words_s.__proj__Mkfour__item__lo0 ctr_BE `op_Modulus` 256 /\ va_get_xmm 9
va_s0 == Vale.Def.Types_s.quad32_xor (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.AES.GCTR.inc32lite ctr_BE 0)) (va_get_xmm 15 va_s0) /\ (va_get_reg64 rRbx va_s0 + 6 < 256
==> (va_get_xmm 9 va_s0, va_get_xmm 10 va_s0, va_get_xmm 11 va_s0, va_get_xmm 12 va_s0,
va_get_xmm 13 va_s0, va_get_xmm 14 va_s0) == xor_reverse_inc32lite_6 1 0 ctr_BE (va_get_xmm 15
va_s0)) /\ hkeys_b_powers hkeys_b (va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0)
(va_get_reg64 rR9 va_s0 - 32) h)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in Vale.X64.Decls.modifies_buffer_specific128
scratch_b (va_get_mem_heaplet 3 va_s0) (va_get_mem_heaplet 3 va_sM) 8 8 /\ (let init =
make_six_of #Vale.Def.Types_s.quad32 (fun (n:(va_int_range 0 5)) -> Vale.Def.Types_s.quad32_xor
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE n)) (va_get_xmm 15
va_sM)) in (va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM,
va_get_xmm 13 va_sM, va_get_xmm 14 va_sM) == rounds_opaque_6 init round_keys 0 /\
Vale.X64.Decls.buffer128_read scratch_b 8 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 6) /\ (0 <= va_get_reg64
rRbx va_sM /\ va_get_reg64 rRbx va_sM < 256) /\ va_get_reg64 rRbx va_sM ==
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (Vale.AES.GCTR.inc32lite ctr_BE 6) `op_Modulus` 256
/\ va_get_xmm 3 va_sM == Vale.X64.Decls.buffer128_read hkeys_b 0 (va_get_mem_heaplet 0 va_s0)))
/\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 3 va_sM (va_update_xmm 14
va_sM (va_update_xmm 13 va_sM (va_update_xmm 12 va_sM (va_update_xmm 11 va_sM (va_update_xmm 10
va_sM (va_update_xmm 9 va_sM (va_update_xmm 6 va_sM (va_update_xmm 5 va_sM (va_update_xmm 2
va_sM (va_update_xmm 1 va_sM (va_update_xmm 0 va_sM (va_update_xmm 3 va_sM (va_update_reg64
rR11 va_sM (va_update_reg64 rRbx va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))))))))))))))))
[@"opaque_to_smt"]
let va_lemma_Loop6x_preamble va_b0 va_s0 alg h_LE iv_b scratch_b key_words round_keys keys_b
hkeys_b ctr_BE =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_mem_heaplet 3; va_Mod_xmm 14; va_Mod_xmm 13;
va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 6; va_Mod_xmm 5;
va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_xmm 3; va_Mod_reg64 rR11; va_Mod_reg64 rRbx;
va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_Loop6x_preamble va_mods alg h_LE iv_b scratch_b key_words round_keys keys_b
hkeys_b ctr_BE in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_Loop6x_preamble alg) va_qc va_s0 (fun
va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 402 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_ok va_sM) /\ (let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in label va_range1
"***** POSTCONDITION NOT MET AT line 459 column 72 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 scratch_b (va_get_mem_heaplet 3 va_s0)
(va_get_mem_heaplet 3 va_sM) 8 8) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 464 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(let init = make_six_of #Vale.Def.Types_s.quad32 (fun (n:(va_int_range 0 5)) ->
Vale.Def.Types_s.quad32_xor (Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite
ctr_BE n)) (va_get_xmm 15 va_sM)) in label va_range1
"***** POSTCONDITION NOT MET AT line 466 column 102 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM, va_get_xmm
13 va_sM, va_get_xmm 14 va_sM) == rounds_opaque_6 init round_keys 0) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 469 column 90 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 8 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 6)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 472 column 27 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(0 <= va_get_reg64 rRbx va_sM /\ va_get_reg64 rRbx va_sM < 256) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 473 column 50 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_reg64 rRbx va_sM == Vale.Def.Words_s.__proj__Mkfour__item__lo0 (Vale.AES.GCTR.inc32lite
ctr_BE 6) `op_Modulus` 256) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 475 column 55 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_xmm 3 va_sM == Vale.X64.Decls.buffer128_read hkeys_b 0 (va_get_mem_heaplet 0 va_s0)))))
in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_mem_heaplet 3; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm
12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2;
va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_xmm 3; va_Mod_reg64 rR11; va_Mod_reg64 rRbx; va_Mod_ok;
va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Loop6x_preamble (alg:algorithm) (h_LE:quad32) (iv_b:buffer128) (scratch_b:buffer128)
(key_words:(seq nat32)) (round_keys:(seq quad32)) (keys_b:buffer128) (hkeys_b:buffer128)
(ctr_BE:quad32) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in sse_enabled /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 3 va_s0) (va_get_reg64 rRbp va_s0) scratch_b 9 (va_get_mem_layout va_s0)
Secret /\ aes_reqs_offset alg key_words round_keys keys_b (va_get_reg64 rRcx va_s0)
(va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0) /\ va_get_xmm 15 va_s0 ==
FStar.Seq.Base.index #quad32 round_keys 0 /\ va_get_xmm 2 va_s0 == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 0 0 0 16777216 /\ va_get_xmm 1 va_s0 ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 0) /\ va_get_reg64 rRbx
va_s0 == Vale.Def.Words_s.__proj__Mkfour__item__lo0 ctr_BE `op_Modulus` 256 /\ va_get_xmm 9
va_s0 == Vale.Def.Types_s.quad32_xor (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.AES.GCTR.inc32lite ctr_BE 0)) (va_get_xmm 15 va_s0) /\ (va_get_reg64 rRbx va_s0 + 6 < 256
==> (va_get_xmm 9 va_s0, va_get_xmm 10 va_s0, va_get_xmm 11 va_s0, va_get_xmm 12 va_s0,
va_get_xmm 13 va_s0, va_get_xmm 14 va_s0) == xor_reverse_inc32lite_6 1 0 ctr_BE (va_get_xmm 15
va_s0)) /\ hkeys_b_powers hkeys_b (va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0)
(va_get_reg64 rR9 va_s0 - 32) h) /\ (forall (va_x_mem:vale_heap) (va_x_rbx:nat64)
(va_x_r11:nat64) (va_x_xmm3:quad32) (va_x_xmm0:quad32) (va_x_xmm1:quad32) (va_x_xmm2:quad32)
(va_x_xmm5:quad32) (va_x_xmm6:quad32) (va_x_xmm9:quad32) (va_x_xmm10:quad32)
(va_x_xmm11:quad32) (va_x_xmm12:quad32) (va_x_xmm13:quad32) (va_x_xmm14:quad32)
(va_x_heap3:vale_heap) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_mem_heaplet 3 va_x_heap3 (va_upd_xmm 14 va_x_xmm14 (va_upd_xmm 13 va_x_xmm13
(va_upd_xmm 12 va_x_xmm12 (va_upd_xmm 11 va_x_xmm11 (va_upd_xmm 10 va_x_xmm10 (va_upd_xmm 9
va_x_xmm9 (va_upd_xmm 6 va_x_xmm6 (va_upd_xmm 5 va_x_xmm5 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1
va_x_xmm1 (va_upd_xmm 0 va_x_xmm0 (va_upd_xmm 3 va_x_xmm3 (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rRbx va_x_rbx (va_upd_mem va_x_mem va_s0)))))))))))))))) in va_get_ok va_sM /\
(let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in Vale.X64.Decls.modifies_buffer_specific128
scratch_b (va_get_mem_heaplet 3 va_s0) (va_get_mem_heaplet 3 va_sM) 8 8 /\ (let init =
make_six_of #Vale.Def.Types_s.quad32 (fun (n:(va_int_range 0 5)) -> Vale.Def.Types_s.quad32_xor
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE n)) (va_get_xmm 15
va_sM)) in (va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM,
va_get_xmm 13 va_sM, va_get_xmm 14 va_sM) == rounds_opaque_6 init round_keys 0 /\
Vale.X64.Decls.buffer128_read scratch_b 8 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 6) /\ (0 <= va_get_reg64
rRbx va_sM /\ va_get_reg64 rRbx va_sM < 256) /\ va_get_reg64 rRbx va_sM ==
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (Vale.AES.GCTR.inc32lite ctr_BE 6) `op_Modulus` 256
/\ va_get_xmm 3 va_sM == Vale.X64.Decls.buffer128_read hkeys_b 0 (va_get_mem_heaplet 0 va_s0)))
==> va_k va_sM (())))
val va_wpProof_Loop6x_preamble : alg:algorithm -> h_LE:quad32 -> iv_b:buffer128 ->
scratch_b:buffer128 -> key_words:(seq nat32) -> round_keys:(seq quad32) -> keys_b:buffer128 ->
hkeys_b:buffer128 -> ctr_BE:quad32 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Loop6x_preamble alg h_LE iv_b scratch_b key_words
round_keys keys_b hkeys_b ctr_BE va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Loop6x_preamble alg) ([va_Mod_flags;
va_Mod_mem_heaplet 3; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm
10; va_Mod_xmm 9; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0;
va_Mod_xmm 3; va_Mod_reg64 rR11; va_Mod_reg64 rRbx; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0,
va_g))))
[@"opaque_to_smt"]
let va_wpProof_Loop6x_preamble alg h_LE iv_b scratch_b key_words round_keys keys_b hkeys_b ctr_BE
va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Loop6x_preamble (va_code_Loop6x_preamble alg) va_s0 alg h_LE iv_b
scratch_b key_words round_keys keys_b hkeys_b ctr_BE in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 3 va_sM (va_update_xmm 14
va_sM (va_update_xmm 13 va_sM (va_update_xmm 12 va_sM (va_update_xmm 11 va_sM (va_update_xmm 10
va_sM (va_update_xmm 9 va_sM (va_update_xmm 6 va_sM (va_update_xmm 5 va_sM (va_update_xmm 2
va_sM (va_update_xmm 1 va_sM (va_update_xmm 0 va_sM (va_update_xmm 3 va_sM (va_update_reg64
rR11 va_sM (va_update_reg64 rRbx va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0)))))))))))))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_mem_heaplet 3; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm
12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2;
va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_xmm 3; va_Mod_reg64 rR11; va_Mod_reg64 rRbx; va_Mod_mem])
va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Loop6x_preamble (alg:algorithm) (h_LE:quad32) (iv_b:buffer128) (scratch_b:buffer128)
(key_words:(seq nat32)) (round_keys:(seq quad32)) (keys_b:buffer128) (hkeys_b:buffer128)
(ctr_BE:quad32) : (va_quickCode unit (va_code_Loop6x_preamble alg)) =
(va_QProc (va_code_Loop6x_preamble alg) ([va_Mod_flags; va_Mod_mem_heaplet 3; va_Mod_xmm 14;
va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 6;
va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_xmm 3; va_Mod_reg64 rR11;
va_Mod_reg64 rRbx; va_Mod_mem]) (va_wp_Loop6x_preamble alg h_LE iv_b scratch_b key_words
round_keys keys_b hkeys_b ctr_BE) (va_wpProof_Loop6x_preamble alg h_LE iv_b scratch_b key_words
round_keys keys_b hkeys_b ctr_BE))
//--
//-- Loop6x_reverse128
val va_code_Loop6x_reverse128 : in0_offset:nat -> stack_offset:nat -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_Loop6x_reverse128 in0_offset stack_offset =
(va_Block (va_CCons (va_code_LoadBe64_buffer128 (va_op_heaplet_mem_heaplet 6)
(va_op_reg_opr64_reg64 rR13) (va_op_reg_opr64_reg64 rR14) (in0_offset `op_Multiply` 16 + 8)
Secret true) (va_CCons (va_code_LoadBe64_buffer128 (va_op_heaplet_mem_heaplet 6)
(va_op_reg_opr64_reg64 rR12) (va_op_reg_opr64_reg64 rR14) (in0_offset `op_Multiply` 16) Secret
false) (va_CCons (va_code_Store64_buffer128 (va_op_heaplet_mem_heaplet 3)
(va_op_reg_opr64_reg64 rRbp) (va_op_reg_opr64_reg64 rR13) (stack_offset `op_Multiply` 16)
Secret false) (va_CCons (va_code_Store64_buffer128 (va_op_heaplet_mem_heaplet 3)
(va_op_reg_opr64_reg64 rRbp) (va_op_reg_opr64_reg64 rR12) (stack_offset `op_Multiply` 16 + 8)
Secret true) (va_CNil ()))))))
val va_codegen_success_Loop6x_reverse128 : in0_offset:nat -> stack_offset:nat -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_Loop6x_reverse128 in0_offset stack_offset =
(va_pbool_and (va_codegen_success_LoadBe64_buffer128 (va_op_heaplet_mem_heaplet 6)
(va_op_reg_opr64_reg64 rR13) (va_op_reg_opr64_reg64 rR14) (in0_offset `op_Multiply` 16 + 8)
Secret true) (va_pbool_and (va_codegen_success_LoadBe64_buffer128 (va_op_heaplet_mem_heaplet 6)
(va_op_reg_opr64_reg64 rR12) (va_op_reg_opr64_reg64 rR14) (in0_offset `op_Multiply` 16) Secret
false) (va_pbool_and (va_codegen_success_Store64_buffer128 (va_op_heaplet_mem_heaplet 3)
(va_op_reg_opr64_reg64 rRbp) (va_op_reg_opr64_reg64 rR13) (stack_offset `op_Multiply` 16)
Secret false) (va_pbool_and (va_codegen_success_Store64_buffer128 (va_op_heaplet_mem_heaplet 3)
(va_op_reg_opr64_reg64 rRbp) (va_op_reg_opr64_reg64 rR12) (stack_offset `op_Multiply` 16 + 8)
Secret true) (va_ttrue ())))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_Loop6x_reverse128 (va_mods:va_mods_t) (in0_offset:nat) (stack_offset:nat) (start:nat)
(in0_b:buffer128) (scratch_b:buffer128) : (va_quickCode unit (va_code_Loop6x_reverse128
in0_offset stack_offset)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 527 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_LoadBe64_buffer128 (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rR13)
(va_op_reg_opr64_reg64 rR14) (in0_offset `op_Multiply` 16 + 8) Secret true in0_b (start +
in0_offset)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 528 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_LoadBe64_buffer128 (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rR12)
(va_op_reg_opr64_reg64 rR14) (in0_offset `op_Multiply` 16) Secret false in0_b (start +
in0_offset)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 529 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store64_buffer128 (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp)
(va_op_reg_opr64_reg64 rR13) (stack_offset `op_Multiply` 16) Secret false scratch_b
stack_offset) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 530 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store64_buffer128 (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp)
(va_op_reg_opr64_reg64 rR12) (stack_offset `op_Multiply` 16 + 8) Secret true scratch_b
stack_offset) (fun (va_s:va_state) _ -> let (va_arg10:Vale.Def.Types_s.quad32) =
Vale.X64.Decls.buffer128_read scratch_b stack_offset (va_get_mem_heaplet 3 va_s) in let
(va_arg9:Vale.Def.Types_s.quad32) = Vale.X64.Decls.buffer128_read scratch_b stack_offset
(va_get_mem_heaplet 3 va_old_s) in let (va_arg8:Vale.Def.Types_s.quad32) =
Vale.X64.Decls.buffer128_read in0_b (start + in0_offset) (va_get_mem_heaplet 6 va_old_s) in
va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 531 column 34 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.Arch.Types.lemma_reverse_bytes_quad32_64 va_arg8 va_arg9 va_arg10)
(va_QEmpty (()))))))))
val va_lemma_Loop6x_reverse128 : va_b0:va_code -> va_s0:va_state -> in0_offset:nat ->
stack_offset:nat -> start:nat -> in0_b:buffer128 -> scratch_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Loop6x_reverse128 in0_offset stack_offset) va_s0 /\
va_get_ok va_s0 /\ (sse_enabled /\ movbe_enabled /\ Vale.X64.Decls.validSrcAddrsOffset128
(va_get_mem_heaplet 6 va_s0) (va_get_reg64 rR14 va_s0) in0_b start (in0_offset + 1)
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 3
va_s0) (va_get_reg64 rRbp va_s0) scratch_b (stack_offset + 1) (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 /\
(Vale.X64.Decls.modifies_buffer_specific128 scratch_b (va_get_mem_heaplet 3 va_s0)
(va_get_mem_heaplet 3 va_sM) stack_offset stack_offset /\ Vale.X64.Decls.buffer128_read
scratch_b stack_offset (va_get_mem_heaplet 3 va_sM) == Vale.Def.Types_s.reverse_bytes_quad32
(Vale.X64.Decls.buffer128_read in0_b (start + in0_offset) (va_get_mem_heaplet 6 va_s0))) /\
va_state_eq va_sM (va_update_mem_heaplet 3 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64
rR12 va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))
[@"opaque_to_smt"]
let va_lemma_Loop6x_reverse128 va_b0 va_s0 in0_offset stack_offset start in0_b scratch_b =
let (va_mods:va_mods_t) = [va_Mod_mem_heaplet 3; va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_ok;
va_Mod_mem] in
let va_qc = va_qcode_Loop6x_reverse128 va_mods in0_offset stack_offset start in0_b scratch_b in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_Loop6x_reverse128 in0_offset
stack_offset) va_qc va_s0 (fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 504 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_ok va_sM) /\ (label va_range1
"***** POSTCONDITION NOT MET AT line 523 column 94 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 scratch_b (va_get_mem_heaplet 3 va_s0)
(va_get_mem_heaplet 3 va_sM) stack_offset stack_offset) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 525 column 88 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b stack_offset (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b (start + in0_offset)
(va_get_mem_heaplet 6 va_s0))))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_mem_heaplet 3; va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_ok;
va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Loop6x_reverse128 (in0_offset:nat) (stack_offset:nat) (start:nat) (in0_b:buffer128)
(scratch_b:buffer128) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (sse_enabled /\ movbe_enabled /\ Vale.X64.Decls.validSrcAddrsOffset128
(va_get_mem_heaplet 6 va_s0) (va_get_reg64 rR14 va_s0) in0_b start (in0_offset + 1)
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 3
va_s0) (va_get_reg64 rRbp va_s0) scratch_b (stack_offset + 1) (va_get_mem_layout va_s0) Secret)
/\ (forall (va_x_mem:vale_heap) (va_x_r12:nat64) (va_x_r13:nat64) (va_x_heap3:vale_heap) . let
va_sM = va_upd_mem_heaplet 3 va_x_heap3 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rR12 va_x_r12
(va_upd_mem va_x_mem va_s0))) in va_get_ok va_sM /\ (Vale.X64.Decls.modifies_buffer_specific128
scratch_b (va_get_mem_heaplet 3 va_s0) (va_get_mem_heaplet 3 va_sM) stack_offset stack_offset
/\ Vale.X64.Decls.buffer128_read scratch_b stack_offset (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b (start + in0_offset)
(va_get_mem_heaplet 6 va_s0))) ==> va_k va_sM (())))
val va_wpProof_Loop6x_reverse128 : in0_offset:nat -> stack_offset:nat -> start:nat ->
in0_b:buffer128 -> scratch_b:buffer128 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Loop6x_reverse128 in0_offset stack_offset start in0_b
scratch_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Loop6x_reverse128 in0_offset
stack_offset) ([va_Mod_mem_heaplet 3; va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Loop6x_reverse128 in0_offset stack_offset start in0_b scratch_b va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Loop6x_reverse128 (va_code_Loop6x_reverse128 in0_offset
stack_offset) va_s0 in0_offset stack_offset start in0_b scratch_b in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_mem_heaplet 3 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR12 va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))));
va_lemma_norm_mods ([va_Mod_mem_heaplet 3; va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_mem])
va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Loop6x_reverse128 (in0_offset:nat) (stack_offset:nat) (start:nat) (in0_b:buffer128)
(scratch_b:buffer128) : (va_quickCode unit (va_code_Loop6x_reverse128 in0_offset stack_offset)) =
(va_QProc (va_code_Loop6x_reverse128 in0_offset stack_offset) ([va_Mod_mem_heaplet 3;
va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_mem]) (va_wp_Loop6x_reverse128 in0_offset
stack_offset start in0_b scratch_b) (va_wpProof_Loop6x_reverse128 in0_offset stack_offset start
in0_b scratch_b))
//--
//-- Loop6x_round9
val va_code_Loop6x_round9 : alg:algorithm -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_Loop6x_round9 alg =
(va_Block (va_CCons (va_code_Store128_buffer (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64
rRbp) (va_op_xmm_xmm 7) 16 Secret) (va_CCons (va_code_Mem128_lemma ()) (va_CCons (va_code_VPxor
(va_op_xmm_xmm 2) (va_op_xmm_xmm 1) (va_opr_code_Mem128 (va_op_heaplet_mem_heaplet 6)
(va_op_reg64_reg64 rRdi) 0 Secret)) (va_CCons (va_code_Mem128_lemma ()) (va_CCons
(va_code_VPxor (va_op_xmm_xmm 0) (va_op_xmm_xmm 1) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 16 Secret)) (va_CCons
(va_code_Mem128_lemma ()) (va_CCons (va_code_VPxor (va_op_xmm_xmm 5) (va_op_xmm_xmm 1)
(va_opr_code_Mem128 (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 32 Secret))
(va_CCons (va_code_Mem128_lemma ()) (va_CCons (va_code_VPxor (va_op_xmm_xmm 6) (va_op_xmm_xmm
1) (va_opr_code_Mem128 (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 48 Secret))
(va_CCons (va_code_Mem128_lemma ()) (va_CCons (va_code_VPxor (va_op_xmm_xmm 7) (va_op_xmm_xmm
1) (va_opr_code_Mem128 (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 64 Secret))
(va_CCons (va_code_Mem128_lemma ()) (va_CCons (va_code_VPxor (va_op_xmm_xmm 3) (va_op_xmm_xmm
1) (va_opr_code_Mem128 (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 80 Secret))
(va_CNil ())))))))))))))))
val va_codegen_success_Loop6x_round9 : alg:algorithm -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_Loop6x_round9 alg =
(va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 3)
(va_op_reg_opr64_reg64 rRbp) (va_op_xmm_xmm 7) 16 Secret) (va_pbool_and
(va_codegen_success_Mem128_lemma ()) (va_pbool_and (va_codegen_success_VPxor (va_op_xmm_xmm 2)
(va_op_xmm_xmm 1) (va_opr_code_Mem128 (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 0
Secret)) (va_pbool_and (va_codegen_success_Mem128_lemma ()) (va_pbool_and
(va_codegen_success_VPxor (va_op_xmm_xmm 0) (va_op_xmm_xmm 1) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 16 Secret)) (va_pbool_and
(va_codegen_success_Mem128_lemma ()) (va_pbool_and (va_codegen_success_VPxor (va_op_xmm_xmm 5)
(va_op_xmm_xmm 1) (va_opr_code_Mem128 (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 32
Secret)) (va_pbool_and (va_codegen_success_Mem128_lemma ()) (va_pbool_and
(va_codegen_success_VPxor (va_op_xmm_xmm 6) (va_op_xmm_xmm 1) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 48 Secret)) (va_pbool_and
(va_codegen_success_Mem128_lemma ()) (va_pbool_and (va_codegen_success_VPxor (va_op_xmm_xmm 7)
(va_op_xmm_xmm 1) (va_opr_code_Mem128 (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 64
Secret)) (va_pbool_and (va_codegen_success_Mem128_lemma ()) (va_pbool_and
(va_codegen_success_VPxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 1) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 80 Secret)) (va_ttrue ()))))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_Loop6x_round9 (va_mods:va_mods_t) (alg:algorithm) (count:nat) (in_b:buffer128)
(scratch_b:buffer128) (key_words:(seq nat32)) (round_keys:(seq quad32)) (keys_b:buffer128) :
(va_quickCode unit (va_code_Loop6x_round9 alg)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 567 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp)
(va_op_xmm_xmm 7) 16 Secret scratch_b 1) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 568 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mem128_lemma (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 0 Secret in_b
(count `op_Multiply` 6 + 0)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 568 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 0 Secret)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 569 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mem128_lemma (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 16 Secret in_b
(count `op_Multiply` 6 + 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 569 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 0) (va_op_xmm_xmm 1) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 16 Secret)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 570 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mem128_lemma (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 32 Secret in_b
(count `op_Multiply` 6 + 2)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 570 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 5) (va_op_xmm_xmm 1) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 32 Secret)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 571 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mem128_lemma (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 48 Secret in_b
(count `op_Multiply` 6 + 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 571 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 6) (va_op_xmm_xmm 1) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 48 Secret)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 572 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mem128_lemma (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 64 Secret in_b
(count `op_Multiply` 6 + 4)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 572 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 7) (va_op_xmm_xmm 1) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 64 Secret)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 573 column 28 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mem128_lemma (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 80 Secret in_b
(count `op_Multiply` 6 + 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 573 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 1) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 80 Secret)) (va_QEmpty
(()))))))))))))))))
val va_lemma_Loop6x_round9 : va_b0:va_code -> va_s0:va_state -> alg:algorithm -> count:nat ->
in_b:buffer128 -> scratch_b:buffer128 -> key_words:(seq nat32) -> round_keys:(seq quad32) ->
keys_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Loop6x_round9 alg) va_s0 /\ va_get_ok va_s0 /\
(sse_enabled /\ Vale.X64.Decls.validSrcAddrsOffset128 (va_get_mem_heaplet 6 va_s0)
(va_get_reg64 rRdi va_s0) in_b (count `op_Multiply` 6) 6 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 3 va_s0) (va_get_reg64 rRbp va_s0)
scratch_b 8 (va_get_mem_layout va_s0) Secret /\ aes_reqs_offset alg key_words round_keys keys_b
(va_get_reg64 rRcx va_s0) (va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0) /\ va_get_xmm
1 va_s0 == Vale.X64.Decls.buffer128_read keys_b (Vale.AES.AES_common_s.nr alg)
(va_get_mem_heaplet 0 va_s0))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(Vale.X64.Decls.modifies_buffer_specific128 scratch_b (va_get_mem_heaplet 3 va_s0)
(va_get_mem_heaplet 3 va_sM) 1 1 /\ (va_get_xmm 2 va_sM, va_get_xmm 0 va_sM, va_get_xmm 5
va_sM, va_get_xmm 6 va_sM, va_get_xmm 7 va_sM, va_get_xmm 3 va_sM) == make_six_of #quad32 (fun
(i:(va_int_range 0 5)) -> Vale.Def.Types_s.quad32_xor (FStar.Seq.Base.index
#Vale.Def.Types_s.quad32 round_keys (Vale.AES.AES_common_s.nr alg))
(Vale.X64.Decls.buffer128_read in_b (count `op_Multiply` 6 + i) (va_get_mem_heaplet 6 va_sM)))
/\ Vale.X64.Decls.buffer128_read scratch_b 1 (va_get_mem_heaplet 3 va_sM) == va_get_xmm 7
va_s0) /\ va_state_eq va_sM (va_update_mem_heaplet 3 va_sM (va_update_flags va_sM
(va_update_xmm 7 va_sM (va_update_xmm 6 va_sM (va_update_xmm 5 va_sM (va_update_xmm 3 va_sM
(va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_xmm 0 va_sM (va_update_ok va_sM
(va_update_mem va_sM va_s0)))))))))))))
[@"opaque_to_smt"]
let va_lemma_Loop6x_round9 va_b0 va_s0 alg count in_b scratch_b key_words round_keys keys_b =
let (va_mods:va_mods_t) = [va_Mod_mem_heaplet 3; va_Mod_flags; va_Mod_xmm 7; va_Mod_xmm 6;
va_Mod_xmm 5; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_Loop6x_round9 va_mods alg count in_b scratch_b key_words round_keys keys_b in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_Loop6x_round9 alg) va_qc va_s0 (fun
va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 535 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_ok va_sM) /\ (label va_range1
"***** POSTCONDITION NOT MET AT line 561 column 72 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 scratch_b (va_get_mem_heaplet 3 va_s0)
(va_get_mem_heaplet 3 va_sM) 1 1) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 563 column 102 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((va_get_xmm 2 va_sM, va_get_xmm 0 va_sM, va_get_xmm 5 va_sM, va_get_xmm 6 va_sM, va_get_xmm 7
va_sM, va_get_xmm 3 va_sM) == make_six_of #quad32 (fun (i:(va_int_range 0 5)) ->
Vale.Def.Types_s.quad32_xor (FStar.Seq.Base.index #Vale.Def.Types_s.quad32 round_keys
(Vale.AES.AES_common_s.nr alg)) (Vale.X64.Decls.buffer128_read in_b (count `op_Multiply` 6 + i)
(va_get_mem_heaplet 6 va_sM)))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 564 column 55 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 1 (va_get_mem_heaplet 3 va_sM) == va_get_xmm 7
va_s0))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_mem_heaplet 3; va_Mod_flags; va_Mod_xmm 7; va_Mod_xmm 6; va_Mod_xmm
5; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Loop6x_round9 (alg:algorithm) (count:nat) (in_b:buffer128) (scratch_b:buffer128)
(key_words:(seq nat32)) (round_keys:(seq quad32)) (keys_b:buffer128) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (sse_enabled /\ Vale.X64.Decls.validSrcAddrsOffset128 (va_get_mem_heaplet 6
va_s0) (va_get_reg64 rRdi va_s0) in_b (count `op_Multiply` 6) 6 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 3 va_s0) (va_get_reg64 rRbp
va_s0) scratch_b 8 (va_get_mem_layout va_s0) Secret /\ aes_reqs_offset alg key_words round_keys
keys_b (va_get_reg64 rRcx va_s0) (va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0) /\
va_get_xmm 1 va_s0 == Vale.X64.Decls.buffer128_read keys_b (Vale.AES.AES_common_s.nr alg)
(va_get_mem_heaplet 0 va_s0)) /\ (forall (va_x_mem:vale_heap) (va_x_xmm0:quad32)
(va_x_xmm1:quad32) (va_x_xmm2:quad32) (va_x_xmm3:quad32) (va_x_xmm5:quad32) (va_x_xmm6:quad32)
(va_x_xmm7:quad32) (va_x_efl:Vale.X64.Flags.t) (va_x_heap3:vale_heap) . let va_sM =
va_upd_mem_heaplet 3 va_x_heap3 (va_upd_flags va_x_efl (va_upd_xmm 7 va_x_xmm7 (va_upd_xmm 6
va_x_xmm6 (va_upd_xmm 5 va_x_xmm5 (va_upd_xmm 3 va_x_xmm3 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1
va_x_xmm1 (va_upd_xmm 0 va_x_xmm0 (va_upd_mem va_x_mem va_s0))))))))) in va_get_ok va_sM /\
(Vale.X64.Decls.modifies_buffer_specific128 scratch_b (va_get_mem_heaplet 3 va_s0)
(va_get_mem_heaplet 3 va_sM) 1 1 /\ (va_get_xmm 2 va_sM, va_get_xmm 0 va_sM, va_get_xmm 5
va_sM, va_get_xmm 6 va_sM, va_get_xmm 7 va_sM, va_get_xmm 3 va_sM) == make_six_of #quad32 (fun
(i:(va_int_range 0 5)) -> Vale.Def.Types_s.quad32_xor (FStar.Seq.Base.index
#Vale.Def.Types_s.quad32 round_keys (Vale.AES.AES_common_s.nr alg))
(Vale.X64.Decls.buffer128_read in_b (count `op_Multiply` 6 + i) (va_get_mem_heaplet 6 va_sM)))
/\ Vale.X64.Decls.buffer128_read scratch_b 1 (va_get_mem_heaplet 3 va_sM) == va_get_xmm 7
va_s0) ==> va_k va_sM (())))
val va_wpProof_Loop6x_round9 : alg:algorithm -> count:nat -> in_b:buffer128 -> scratch_b:buffer128
-> key_words:(seq nat32) -> round_keys:(seq quad32) -> keys_b:buffer128 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Loop6x_round9 alg count in_b scratch_b key_words
round_keys keys_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Loop6x_round9 alg)
([va_Mod_mem_heaplet 3; va_Mod_flags; va_Mod_xmm 7; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 3;
va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Loop6x_round9 alg count in_b scratch_b key_words round_keys keys_b va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Loop6x_round9 (va_code_Loop6x_round9 alg) va_s0 alg count in_b
scratch_b key_words round_keys keys_b in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_mem_heaplet 3 va_sM (va_update_flags va_sM (va_update_xmm 7
va_sM (va_update_xmm 6 va_sM (va_update_xmm 5 va_sM (va_update_xmm 3 va_sM (va_update_xmm 2
va_sM (va_update_xmm 1 va_sM (va_update_xmm 0 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))))))));
va_lemma_norm_mods ([va_Mod_mem_heaplet 3; va_Mod_flags; va_Mod_xmm 7; va_Mod_xmm 6; va_Mod_xmm
5; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Loop6x_round9 (alg:algorithm) (count:nat) (in_b:buffer128) (scratch_b:buffer128)
(key_words:(seq nat32)) (round_keys:(seq quad32)) (keys_b:buffer128) : (va_quickCode unit
(va_code_Loop6x_round9 alg)) =
(va_QProc (va_code_Loop6x_round9 alg) ([va_Mod_mem_heaplet 3; va_Mod_flags; va_Mod_xmm 7;
va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0;
va_Mod_mem]) (va_wp_Loop6x_round9 alg count in_b scratch_b key_words round_keys keys_b)
(va_wpProof_Loop6x_round9 alg count in_b scratch_b key_words round_keys keys_b))
//--
//-- load_one_msb
val va_code_load_one_msb : va_dummy:unit -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_load_one_msb () =
(va_Block (va_CCons (va_code_ZeroXmm (va_op_xmm_xmm 2)) (va_CCons (va_code_PinsrqImm
(va_op_xmm_xmm 2) 72057594037927936 1 (va_op_reg_opr64_reg64 rR11)) (va_CNil ()))))
val va_codegen_success_load_one_msb : va_dummy:unit -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_load_one_msb () =
(va_pbool_and (va_codegen_success_ZeroXmm (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_PinsrqImm (va_op_xmm_xmm 2) 72057594037927936 1 (va_op_reg_opr64_reg64
rR11)) (va_ttrue ())))
[@ "opaque_to_smt" va_qattr]
let va_qcode_load_one_msb (va_mods:va_mods_t) : (va_quickCode unit (va_code_load_one_msb ())) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QBind va_range1
"***** PRECONDITION NOT MET AT line 583 column 12 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_ZeroXmm (va_op_xmm_xmm 2)) (fun (va_s:va_state) _ -> va_qAssert va_range1
"***** PRECONDITION NOT MET AT line 584 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.Arch.Types.two_to_nat32 (Vale.Def.Words_s.Mktwo #Vale.Def.Words_s.nat32 0 16777216) ==
72057594037927936) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 585 column 14 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_PinsrqImm (va_op_xmm_xmm 2) 72057594037927936 1 (va_op_reg_opr64_reg64 rR11)) (fun
(va_s:va_state) _ -> va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 586 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.Def.Types_s.insert_nat64_reveal ()) (va_QEmpty (())))))))
val va_lemma_load_one_msb : va_b0:va_code -> va_s0:va_state
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_load_one_msb ()) va_s0 /\ va_get_ok va_s0 /\
sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_xmm 2 va_sM == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 16777216 /\
va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 2 va_sM (va_update_reg64 rR11 va_sM
(va_update_ok va_sM va_s0))))))
[@"opaque_to_smt"]
let va_lemma_load_one_msb va_b0 va_s0 =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 2; va_Mod_reg64 rR11; va_Mod_ok] in
let va_qc = va_qcode_load_one_msb va_mods in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_load_one_msb ()) va_qc va_s0 (fun va_s0
va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 576 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 581 column 46 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_xmm 2 va_sM == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 16777216)) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 2; va_Mod_reg64 rR11; va_Mod_ok]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_load_one_msb (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ sse_enabled /\ (forall (va_x_r11:nat64) (va_x_xmm2:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 2 va_x_xmm2
(va_upd_reg64 rR11 va_x_r11 va_s0)) in va_get_ok va_sM /\ va_get_xmm 2 va_sM ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 16777216 ==> va_k va_sM (())))
val va_wpProof_load_one_msb : va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_load_one_msb va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_load_one_msb ()) ([va_Mod_flags;
va_Mod_xmm 2; va_Mod_reg64 rR11]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_load_one_msb va_s0 va_k =
let (va_sM, va_f0) = va_lemma_load_one_msb (va_code_load_one_msb ()) va_s0 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 2 va_sM (va_update_reg64 rR11
va_sM (va_update_ok va_sM va_s0)))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 2; va_Mod_reg64 rR11]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_load_one_msb () : (va_quickCode unit (va_code_load_one_msb ())) =
(va_QProc (va_code_load_one_msb ()) ([va_Mod_flags; va_Mod_xmm 2; va_Mod_reg64 rR11])
va_wp_load_one_msb va_wpProof_load_one_msb)
//--
//-- Loop6x_final
[@ "opaque_to_smt" va_qattr]
let va_code_Loop6x_final alg =
(va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 3) (va_op_xmm_xmm 1)
(va_op_reg_opr64_reg64 rRbp) 128 Secret) (va_CCons (va_code_VAESNI_enc_last (va_op_xmm_xmm 9)
(va_op_xmm_xmm 9) (va_op_xmm_xmm 2)) (va_CCons (va_code_load_one_msb ()) (va_CCons
(va_code_VAESNI_enc_last (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_xmm_xmm 0)) (va_CCons
(va_code_VPaddd (va_op_xmm_xmm 0) (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_CCons
(va_code_Store64_buffer128 (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp)
(va_op_reg_opr64_reg64 rR13) (7 `op_Multiply` 16) Secret false) (va_CCons (va_code_AddLea64
(va_op_dst_opr64_reg64 rRdi) (va_op_opr64_reg64 rRdi) (va_const_opr64 96)) (va_CCons
(va_code_VAESNI_enc_last (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_xmm_xmm 5)) (va_CCons
(va_code_VPaddd (va_op_xmm_xmm 5) (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_CCons
(va_code_Store64_buffer128 (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp)
(va_op_reg_opr64_reg64 rR12) (7 `op_Multiply` 16 + 8) Secret true) (va_CCons (va_code_AddLea64
(va_op_dst_opr64_reg64 rRsi) (va_op_opr64_reg64 rRsi) (va_const_opr64 96)) (va_CCons
(va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 15) (va_op_reg_opr64_reg64
rRcx) (0 - 128) Secret) (va_CCons (va_code_VAESNI_enc_last (va_op_xmm_xmm 12) (va_op_xmm_xmm
12) (va_op_xmm_xmm 6)) (va_CCons (va_code_VPaddd (va_op_xmm_xmm 6) (va_op_xmm_xmm 5)
(va_op_xmm_xmm 2)) (va_CCons (va_code_VAESNI_enc_last (va_op_xmm_xmm 13) (va_op_xmm_xmm 13)
(va_op_xmm_xmm 7)) (va_CCons (va_code_VPaddd (va_op_xmm_xmm 7) (va_op_xmm_xmm 6) (va_op_xmm_xmm
2)) (va_CCons (va_code_VAESNI_enc_last (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_xmm_xmm 3))
(va_CCons (va_code_VPaddd (va_op_xmm_xmm 3) (va_op_xmm_xmm 7) (va_op_xmm_xmm 2)) (va_CNil
()))))))))))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_Loop6x_final alg =
(va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 3) (va_op_xmm_xmm 1)
(va_op_reg_opr64_reg64 rRbp) 128 Secret) (va_pbool_and (va_codegen_success_VAESNI_enc_last
(va_op_xmm_xmm 9) (va_op_xmm_xmm 9) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_load_one_msb ()) (va_pbool_and (va_codegen_success_VAESNI_enc_last
(va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_xmm_xmm 0)) (va_pbool_and
(va_codegen_success_VPaddd (va_op_xmm_xmm 0) (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Store64_buffer128 (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64
rRbp) (va_op_reg_opr64_reg64 rR13) (7 `op_Multiply` 16) Secret false) (va_pbool_and
(va_codegen_success_AddLea64 (va_op_dst_opr64_reg64 rRdi) (va_op_opr64_reg64 rRdi)
(va_const_opr64 96)) (va_pbool_and (va_codegen_success_VAESNI_enc_last (va_op_xmm_xmm 11)
(va_op_xmm_xmm 11) (va_op_xmm_xmm 5)) (va_pbool_and (va_codegen_success_VPaddd (va_op_xmm_xmm
5) (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_pbool_and (va_codegen_success_Store64_buffer128
(va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp) (va_op_reg_opr64_reg64 rR12) (7
`op_Multiply` 16 + 8) Secret true) (va_pbool_and (va_codegen_success_AddLea64
(va_op_dst_opr64_reg64 rRsi) (va_op_opr64_reg64 rRsi) (va_const_opr64 96)) (va_pbool_and
(va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 15)
(va_op_reg_opr64_reg64 rRcx) (0 - 128) Secret) (va_pbool_and
(va_codegen_success_VAESNI_enc_last (va_op_xmm_xmm 12) (va_op_xmm_xmm 12) (va_op_xmm_xmm 6))
(va_pbool_and (va_codegen_success_VPaddd (va_op_xmm_xmm 6) (va_op_xmm_xmm 5) (va_op_xmm_xmm 2))
(va_pbool_and (va_codegen_success_VAESNI_enc_last (va_op_xmm_xmm 13) (va_op_xmm_xmm 13)
(va_op_xmm_xmm 7)) (va_pbool_and (va_codegen_success_VPaddd (va_op_xmm_xmm 7) (va_op_xmm_xmm 6)
(va_op_xmm_xmm 2)) (va_pbool_and (va_codegen_success_VAESNI_enc_last (va_op_xmm_xmm 14)
(va_op_xmm_xmm 14) (va_op_xmm_xmm 3)) (va_pbool_and (va_codegen_success_VPaddd (va_op_xmm_xmm
3) (va_op_xmm_xmm 7) (va_op_xmm_xmm 2)) (va_ttrue ())))))))))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_Loop6x_final (va_mods:va_mods_t) (alg:algorithm) (iv_b:buffer128)
(scratch_b:buffer128) (key_words:(seq nat32)) (round_keys:(seq quad32)) (keys_b:buffer128)
(ctr_orig:quad32) (init:quad32_6) (ctrs:quad32_6) (plain:quad32_6) (inb:quad32) : (va_quickCode
unit (va_code_Loop6x_final alg)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 667 column 37 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.Arch.TypesNative.lemma_quad32_xor_commutes_forall ()) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 669 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 3) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRbp) 128 Secret scratch_b 8) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 671 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc_last (va_op_xmm_xmm 9) (va_op_xmm_xmm 9) (va_op_xmm_xmm 2)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 672 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_load_one_msb ()) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 673 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc_last (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_xmm_xmm 0)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 674 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 0) (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 675 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store64_buffer128 (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp)
(va_op_reg_opr64_reg64 rR13) (7 `op_Multiply` 16) Secret false scratch_b 7) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 676 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_AddLea64 (va_op_dst_opr64_reg64 rRdi) (va_op_opr64_reg64 rRdi) (va_const_opr64 96))
(va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 677 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc_last (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_xmm_xmm 5)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 678 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 5) (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 679 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store64_buffer128 (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp)
(va_op_reg_opr64_reg64 rR12) (7 `op_Multiply` 16 + 8) Secret true scratch_b 7) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 680 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_AddLea64 (va_op_dst_opr64_reg64 rRsi) (va_op_opr64_reg64 rRsi) (va_const_opr64 96))
(va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 681 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 15)
(va_op_reg_opr64_reg64 rRcx) (0 - 128) Secret keys_b 0) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 683 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc_last (va_op_xmm_xmm 12) (va_op_xmm_xmm 12) (va_op_xmm_xmm 6)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 684 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 6) (va_op_xmm_xmm 5) (va_op_xmm_xmm 2)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 685 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc_last (va_op_xmm_xmm 13) (va_op_xmm_xmm 13) (va_op_xmm_xmm 7)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 686 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 7) (va_op_xmm_xmm 6) (va_op_xmm_xmm 2)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 687 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc_last (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_xmm_xmm 3)) (va_QBind
va_range1
"***** PRECONDITION NOT MET AT line 688 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 3) (va_op_xmm_xmm 7) (va_op_xmm_xmm 2)) (fun (va_s:va_state) _
-> let (va_arg117:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = round_keys in let
(va_arg116:Vale.Def.Types_s.quad32) = va_get_xmm 9 va_s in let
(va_arg115:Vale.Def.Types_s.quad32) = va_get_xmm 9 va_old_s in let
(va_arg114:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___1 #quad32 #quad32 #quad32
#quad32 #quad32 #quad32 init in let (va_arg113:Vale.Def.Types_s.quad32) =
__proj__Mktuple6__item___1 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 plain in let
(va_arg112:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___1 #quad32 #quad32 #quad32
#quad32 #quad32 #quad32 ctrs in let (va_arg111:Vale.AES.AES_common_s.algorithm) = alg in
va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 690 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.finish_cipher_opt va_arg111 va_arg112 va_arg113 va_arg114
va_arg115 va_arg116 va_arg117) (let (va_arg110:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) =
round_keys in let (va_arg109:Vale.Def.Types_s.quad32) = va_get_xmm 10 va_s in let
(va_arg108:Vale.Def.Types_s.quad32) = va_get_xmm 10 va_old_s in let
(va_arg107:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___2 #quad32 #quad32 #quad32
#quad32 #quad32 #quad32 init in let (va_arg106:Vale.Def.Types_s.quad32) =
__proj__Mktuple6__item___2 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 plain in let
(va_arg105:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___2 #quad32 #quad32 #quad32
#quad32 #quad32 #quad32 ctrs in let (va_arg104:Vale.AES.AES_common_s.algorithm) = alg in
va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 691 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.finish_cipher_opt va_arg104 va_arg105 va_arg106 va_arg107
va_arg108 va_arg109 va_arg110) (let (va_arg103:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) =
round_keys in let (va_arg102:Vale.Def.Types_s.quad32) = va_get_xmm 11 va_s in let
(va_arg101:Vale.Def.Types_s.quad32) = va_get_xmm 11 va_old_s in let
(va_arg100:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___3 #quad32 #quad32 #quad32
#quad32 #quad32 #quad32 init in let (va_arg99:Vale.Def.Types_s.quad32) =
__proj__Mktuple6__item___3 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 plain in let
(va_arg98:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___3 #quad32 #quad32 #quad32 #quad32
#quad32 #quad32 ctrs in let (va_arg97:Vale.AES.AES_common_s.algorithm) = alg in va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 692 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.finish_cipher_opt va_arg97 va_arg98 va_arg99 va_arg100
va_arg101 va_arg102 va_arg103) (let (va_arg96:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) =
round_keys in let (va_arg95:Vale.Def.Types_s.quad32) = va_get_xmm 12 va_s in let
(va_arg94:Vale.Def.Types_s.quad32) = va_get_xmm 12 va_old_s in let
(va_arg93:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___4 #quad32 #quad32 #quad32 #quad32
#quad32 #quad32 init in let (va_arg92:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___4
#quad32 #quad32 #quad32 #quad32 #quad32 #quad32 plain in let (va_arg91:Vale.Def.Types_s.quad32)
= __proj__Mktuple6__item___4 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs in let
(va_arg90:Vale.AES.AES_common_s.algorithm) = alg in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 693 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.finish_cipher_opt va_arg90 va_arg91 va_arg92 va_arg93
va_arg94 va_arg95 va_arg96) (let (va_arg89:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) =
round_keys in let (va_arg88:Vale.Def.Types_s.quad32) = va_get_xmm 13 va_s in let
(va_arg87:Vale.Def.Types_s.quad32) = va_get_xmm 13 va_old_s in let
(va_arg86:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___5 #quad32 #quad32 #quad32 #quad32
#quad32 #quad32 init in let (va_arg85:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___5
#quad32 #quad32 #quad32 #quad32 #quad32 #quad32 plain in let (va_arg84:Vale.Def.Types_s.quad32)
= __proj__Mktuple6__item___5 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs in let
(va_arg83:Vale.AES.AES_common_s.algorithm) = alg in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 694 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.finish_cipher_opt va_arg83 va_arg84 va_arg85 va_arg86
va_arg87 va_arg88 va_arg89) (let (va_arg82:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) =
round_keys in let (va_arg81:Vale.Def.Types_s.quad32) = va_get_xmm 14 va_s in let
(va_arg80:Vale.Def.Types_s.quad32) = va_get_xmm 14 va_old_s in let
(va_arg79:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___6 #quad32 #quad32 #quad32 #quad32
#quad32 #quad32 init in let (va_arg78:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___6
#quad32 #quad32 #quad32 #quad32 #quad32 #quad32 plain in let (va_arg77:Vale.Def.Types_s.quad32)
= __proj__Mktuple6__item___6 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs in let
(va_arg76:Vale.AES.AES_common_s.algorithm) = alg in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 695 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.finish_cipher_opt va_arg76 va_arg77 va_arg78 va_arg79
va_arg80 va_arg81 va_arg82) (va_QLemma va_range1
"***** PRECONDITION NOT MET AT line 696 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) -> Vale.AES.AES_s.is_aes_key_LE alg
key) alg (__proj__Mktuple6__item___1 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs)
key_words) (fun _ -> (fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) ->
Vale.AES.AES_s.aes_encrypt_LE alg key input_LE == Vale.AES.AES_s.eval_cipher alg input_LE
(Vale.AES.AES_s.key_to_round_keys_LE alg key)) alg (__proj__Mktuple6__item___1 #quad32 #quad32
#quad32 #quad32 #quad32 #quad32 ctrs) key_words) (fun (_:unit) -> finish_aes_encrypt_le alg
(__proj__Mktuple6__item___1 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs) key_words)
(va_QLemma va_range1
"***** PRECONDITION NOT MET AT line 697 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) -> Vale.AES.AES_s.is_aes_key_LE alg
key) alg (__proj__Mktuple6__item___2 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs)
key_words) (fun _ -> (fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) ->
Vale.AES.AES_s.aes_encrypt_LE alg key input_LE == Vale.AES.AES_s.eval_cipher alg input_LE
(Vale.AES.AES_s.key_to_round_keys_LE alg key)) alg (__proj__Mktuple6__item___2 #quad32 #quad32
#quad32 #quad32 #quad32 #quad32 ctrs) key_words) (fun (_:unit) -> finish_aes_encrypt_le alg
(__proj__Mktuple6__item___2 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs) key_words)
(va_QLemma va_range1
"***** PRECONDITION NOT MET AT line 698 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) -> Vale.AES.AES_s.is_aes_key_LE alg
key) alg (__proj__Mktuple6__item___3 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs)
key_words) (fun _ -> (fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) ->
Vale.AES.AES_s.aes_encrypt_LE alg key input_LE == Vale.AES.AES_s.eval_cipher alg input_LE
(Vale.AES.AES_s.key_to_round_keys_LE alg key)) alg (__proj__Mktuple6__item___3 #quad32 #quad32
#quad32 #quad32 #quad32 #quad32 ctrs) key_words) (fun (_:unit) -> finish_aes_encrypt_le alg
(__proj__Mktuple6__item___3 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs) key_words)
(va_QLemma va_range1
"***** PRECONDITION NOT MET AT line 699 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) -> Vale.AES.AES_s.is_aes_key_LE alg
key) alg (__proj__Mktuple6__item___4 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs)
key_words) (fun _ -> (fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) ->
Vale.AES.AES_s.aes_encrypt_LE alg key input_LE == Vale.AES.AES_s.eval_cipher alg input_LE
(Vale.AES.AES_s.key_to_round_keys_LE alg key)) alg (__proj__Mktuple6__item___4 #quad32 #quad32
#quad32 #quad32 #quad32 #quad32 ctrs) key_words) (fun (_:unit) -> finish_aes_encrypt_le alg
(__proj__Mktuple6__item___4 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs) key_words)
(va_QLemma va_range1
"***** PRECONDITION NOT MET AT line 700 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) -> Vale.AES.AES_s.is_aes_key_LE alg
key) alg (__proj__Mktuple6__item___5 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs)
key_words) (fun _ -> (fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) ->
Vale.AES.AES_s.aes_encrypt_LE alg key input_LE == Vale.AES.AES_s.eval_cipher alg input_LE
(Vale.AES.AES_s.key_to_round_keys_LE alg key)) alg (__proj__Mktuple6__item___5 #quad32 #quad32
#quad32 #quad32 #quad32 #quad32 ctrs) key_words) (fun (_:unit) -> finish_aes_encrypt_le alg
(__proj__Mktuple6__item___5 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs) key_words)
(va_QLemma va_range1
"***** PRECONDITION NOT MET AT line 701 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) -> Vale.AES.AES_s.is_aes_key_LE alg
key) alg (__proj__Mktuple6__item___6 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs)
key_words) (fun _ -> (fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) ->
Vale.AES.AES_s.aes_encrypt_LE alg key input_LE == Vale.AES.AES_s.eval_cipher alg input_LE
(Vale.AES.AES_s.key_to_round_keys_LE alg key)) alg (__proj__Mktuple6__item___6 #quad32 #quad32
#quad32 #quad32 #quad32 #quad32 ctrs) key_words) (fun (_:unit) -> finish_aes_encrypt_le alg
(__proj__Mktuple6__item___6 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs) key_words)
(let (va_arg75:Vale.Def.Types_s.quad32) = Vale.X64.Decls.buffer128_read scratch_b 7
(va_get_mem_heaplet 3 va_s) in let (va_arg74:Vale.Def.Types_s.quad32) =
Vale.X64.Decls.buffer128_read scratch_b 7 (va_get_mem_heaplet 3 va_old_s) in let
(va_arg73:Vale.Def.Types_s.quad32) = inb in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 703 column 34 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.Arch.Types.lemma_reverse_bytes_quad32_64 va_arg73 va_arg74 va_arg75) (let
(va_arg72:Vale.Def.Types_s.quad32) = va_get_xmm 0 va_s in let
(va_arg71:Vale.Def.Types_s.quad32) = va_get_xmm 1 va_s in let
(va_arg70:Vale.Def.Types_s.quad32) = ctr_orig in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 705 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_incr_msb va_arg70 va_arg71 va_arg72 1) (let
(va_arg69:Vale.Def.Types_s.quad32) = va_get_xmm 5 va_s in let
(va_arg68:Vale.Def.Types_s.quad32) = va_get_xmm 1 va_s in let
(va_arg67:Vale.Def.Types_s.quad32) = ctr_orig in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 706 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_incr_msb va_arg67 va_arg68 va_arg69 2) (let
(va_arg66:Vale.Def.Types_s.quad32) = va_get_xmm 6 va_s in let
(va_arg65:Vale.Def.Types_s.quad32) = va_get_xmm 1 va_s in let
(va_arg64:Vale.Def.Types_s.quad32) = ctr_orig in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 707 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_incr_msb va_arg64 va_arg65 va_arg66 3) (let
(va_arg63:Vale.Def.Types_s.quad32) = va_get_xmm 7 va_s in let
(va_arg62:Vale.Def.Types_s.quad32) = va_get_xmm 1 va_s in let
(va_arg61:Vale.Def.Types_s.quad32) = ctr_orig in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 708 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_incr_msb va_arg61 va_arg62 va_arg63 4) (let
(va_arg60:Vale.Def.Types_s.quad32) = va_get_xmm 3 va_s in let
(va_arg59:Vale.Def.Types_s.quad32) = va_get_xmm 1 va_s in let
(va_arg58:Vale.Def.Types_s.quad32) = ctr_orig in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 709 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_incr_msb va_arg58 va_arg59 va_arg60 5) (va_QEmpty
(()))))))))))))))))))))))))))))))))))))))))
[@"opaque_to_smt"]
let va_lemma_Loop6x_final va_b0 va_s0 alg iv_b scratch_b key_words round_keys keys_b ctr_orig init
ctrs plain inb =
let (va_mods:va_mods_t) = [va_Mod_mem_heaplet 3; va_Mod_flags; va_Mod_xmm 15; va_Mod_xmm 14;
va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 7;
va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0;
va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_reg64 rR11; va_Mod_reg64 rRsi; va_Mod_reg64 rRdi;
va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_Loop6x_final va_mods alg iv_b scratch_b key_words round_keys keys_b ctr_orig
init ctrs plain inb in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_Loop6x_final alg) va_qc va_s0 (fun
va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 589 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_ok va_sM) /\ (label va_range1
"***** POSTCONDITION NOT MET AT line 649 column 72 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 scratch_b (va_get_mem_heaplet 3 va_s0)
(va_get_mem_heaplet 3 va_sM) 7 7) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 652 column 73 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 7 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 inb) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 654 column 111 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM, va_get_xmm
13 va_sM, va_get_xmm 14 va_sM) == map2_six_of #quad32 #quad32 #quad32 plain ctrs (fun
(p:quad32) (c:quad32) -> Vale.Def.Types_s.quad32_xor p (Vale.AES.AES_s.aes_encrypt_LE alg
key_words c))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 655 column 39 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_xmm 15 va_sM == FStar.Seq.Base.index #quad32 round_keys 0) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 657 column 33 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0 + 96) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 658 column 33 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0 + 96) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 660 column 41 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_xmm 2 va_sM == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 16777216) /\ label
va_range1
"***** POSTCONDITION NOT MET AT line 662 column 55 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read scratch_b 8 (va_get_mem_heaplet 3 va_s0))
/\ label va_range1
"***** POSTCONDITION NOT MET AT line 663 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(let ctr = Vale.Def.Words_s.__proj__Mkfour__item__lo0 ctr_orig `op_Modulus` 256 in label
va_range1
"***** POSTCONDITION NOT MET AT line 665 column 60 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(ctr + 6 < 256 ==> (va_get_xmm 1 va_sM, va_get_xmm 0 va_sM, va_get_xmm 5 va_sM, va_get_xmm 6
va_sM, va_get_xmm 7 va_sM, va_get_xmm 3 va_sM) == xor_reverse_inc32lite_6 0 0 ctr_orig
(va_get_xmm 15 va_sM))))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_mem_heaplet 3; va_Mod_flags; va_Mod_xmm 15; va_Mod_xmm 14; va_Mod_xmm
13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 7; va_Mod_xmm 6;
va_Mod_xmm 5; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_reg64 rR13;
va_Mod_reg64 rR12; va_Mod_reg64 rR11; va_Mod_reg64 rRsi; va_Mod_reg64 rRdi; va_Mod_ok;
va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Loop6x_final alg iv_b scratch_b key_words round_keys keys_b ctr_orig init ctrs plain
inb va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Loop6x_final (va_code_Loop6x_final alg) va_s0 alg iv_b scratch_b
key_words round_keys keys_b ctr_orig init ctrs plain inb in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_mem_heaplet 3 va_sM (va_update_flags va_sM (va_update_xmm 15
va_sM (va_update_xmm 14 va_sM (va_update_xmm 13 va_sM (va_update_xmm 12 va_sM (va_update_xmm 11
va_sM (va_update_xmm 10 va_sM (va_update_xmm 9 va_sM (va_update_xmm 7 va_sM (va_update_xmm 6
va_sM (va_update_xmm 5 va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1
va_sM (va_update_xmm 0 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR12 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdi va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))));
va_lemma_norm_mods ([va_Mod_mem_heaplet 3; va_Mod_flags; va_Mod_xmm 15; va_Mod_xmm 14; va_Mod_xmm
13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 7; va_Mod_xmm 6;
va_Mod_xmm 5; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_reg64 rR13;
va_Mod_reg64 rR12; va_Mod_reg64 rR11; va_Mod_reg64 rRsi; va_Mod_reg64 rRdi; va_Mod_mem]) va_sM
va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Loop6x_save_output
[@ "opaque_to_smt" va_qattr]
let va_code_Loop6x_save_output () =
(va_Block (va_CCons (va_code_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64
rRsi) (va_op_xmm_xmm 9) (0 - 96) Secret) (va_CCons (va_code_VPxor (va_op_xmm_xmm 9)
(va_op_xmm_xmm 1) (va_op_opr128_xmm 15)) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi) (va_op_xmm_xmm 10) (0 - 80) Secret)
(va_CCons (va_code_Mov128 (va_op_xmm_xmm 10) (va_op_xmm_xmm 0)) (va_CCons
(va_code_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi)
(va_op_xmm_xmm 11) (0 - 64) Secret) (va_CCons (va_code_Mov128 (va_op_xmm_xmm 11) (va_op_xmm_xmm
5)) (va_CCons (va_code_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64
rRsi) (va_op_xmm_xmm 12) (0 - 48) Secret) (va_CCons (va_code_Mov128 (va_op_xmm_xmm 12)
(va_op_xmm_xmm 6)) (va_CCons (va_code_Store128_buffer (va_op_heaplet_mem_heaplet 6)
(va_op_reg_opr64_reg64 rRsi) (va_op_xmm_xmm 13) (0 - 32) Secret) (va_CCons (va_code_Mov128
(va_op_xmm_xmm 13) (va_op_xmm_xmm 7)) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi) (va_op_xmm_xmm 14) (0 - 16) Secret)
(va_CCons (va_code_Mov128 (va_op_xmm_xmm 14) (va_op_xmm_xmm 3)) (va_CNil ()))))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_Loop6x_save_output () =
(va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 6)
(va_op_reg_opr64_reg64 rRsi) (va_op_xmm_xmm 9) (0 - 96) Secret) (va_pbool_and
(va_codegen_success_VPxor (va_op_xmm_xmm 9) (va_op_xmm_xmm 1) (va_op_opr128_xmm 15))
(va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 6)
(va_op_reg_opr64_reg64 rRsi) (va_op_xmm_xmm 10) (0 - 80) Secret) (va_pbool_and
(va_codegen_success_Mov128 (va_op_xmm_xmm 10) (va_op_xmm_xmm 0)) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi)
(va_op_xmm_xmm 11) (0 - 64) Secret) (va_pbool_and (va_codegen_success_Mov128 (va_op_xmm_xmm 11)
(va_op_xmm_xmm 5)) (va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet
6) (va_op_reg_opr64_reg64 rRsi) (va_op_xmm_xmm 12) (0 - 48) Secret) (va_pbool_and
(va_codegen_success_Mov128 (va_op_xmm_xmm 12) (va_op_xmm_xmm 6)) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi)
(va_op_xmm_xmm 13) (0 - 32) Secret) (va_pbool_and (va_codegen_success_Mov128 (va_op_xmm_xmm 13)
(va_op_xmm_xmm 7)) (va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet
6) (va_op_reg_opr64_reg64 rRsi) (va_op_xmm_xmm 14) (0 - 16) Secret) (va_pbool_and
(va_codegen_success_Mov128 (va_op_xmm_xmm 14) (va_op_xmm_xmm 3)) (va_ttrue ())))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_Loop6x_save_output (va_mods:va_mods_t) (count:nat) (out_b:buffer128) : (va_quickCode
unit (va_code_Loop6x_save_output ())) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 744 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi)
(va_op_xmm_xmm 9) (0 - 96) Secret out_b (count `op_Multiply` 6 + 0)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 745 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 9) (va_op_xmm_xmm 1) (va_op_opr128_xmm 15)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 746 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi)
(va_op_xmm_xmm 10) (0 - 80) Secret out_b (count `op_Multiply` 6 + 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 747 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mov128 (va_op_xmm_xmm 10) (va_op_xmm_xmm 0)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 748 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi)
(va_op_xmm_xmm 11) (0 - 64) Secret out_b (count `op_Multiply` 6 + 2)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 749 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mov128 (va_op_xmm_xmm 11) (va_op_xmm_xmm 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 750 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi)
(va_op_xmm_xmm 12) (0 - 48) Secret out_b (count `op_Multiply` 6 + 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 751 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mov128 (va_op_xmm_xmm 12) (va_op_xmm_xmm 6)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 752 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi)
(va_op_xmm_xmm 13) (0 - 32) Secret out_b (count `op_Multiply` 6 + 4)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 753 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mov128 (va_op_xmm_xmm 13) (va_op_xmm_xmm 7)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 754 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi)
(va_op_xmm_xmm 14) (0 - 16) Secret out_b (count `op_Multiply` 6 + 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 755 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mov128 (va_op_xmm_xmm 14) (va_op_xmm_xmm 3)) (va_QEmpty (())))))))))))))))
[@"opaque_to_smt"]
let va_lemma_Loop6x_save_output va_b0 va_s0 count out_b =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_mem_heaplet 6; va_Mod_xmm 14; va_Mod_xmm 13;
va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_Loop6x_save_output va_mods count out_b in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_Loop6x_save_output ()) va_qc va_s0 (fun
va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 712 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_ok va_sM) /\ (label va_range1
"***** POSTCONDITION NOT MET AT line 737 column 84 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 out_b (va_get_mem_heaplet 6 va_s0)
(va_get_mem_heaplet 6 va_sM) (count `op_Multiply` 6 + 0) (count `op_Multiply` 6 + 5)) /\ label
va_range1
"***** POSTCONDITION NOT MET AT line 738 column 120 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(FStar.Seq.Base.slice #Vale.X64.Decls.quad32 (Vale.X64.Decls.buffer128_as_seq
(va_get_mem_heaplet 6 va_sM) out_b) 0 (6 `op_Multiply` count) == FStar.Seq.Base.slice
#Vale.X64.Decls.quad32 (Vale.X64.Decls.buffer128_as_seq (va_get_mem_heaplet 6 va_s0) out_b) 0
(6 `op_Multiply` count)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 740 column 92 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((va_get_xmm 9 va_s0, va_get_xmm 10 va_s0, va_get_xmm 11 va_s0, va_get_xmm 12 va_s0, va_get_xmm
13 va_s0, va_get_xmm 14 va_s0) == make_six_of #quad32 (fun (i:(va_int_range 0 5)) ->
Vale.X64.Decls.buffer128_read out_b (count `op_Multiply` 6 + i) (va_get_mem_heaplet 6 va_sM)))
/\ label va_range1
"***** POSTCONDITION NOT MET AT line 742 column 64 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM, va_get_xmm
13 va_sM, va_get_xmm 14 va_sM) == (Vale.Def.Types_s.quad32_xor (va_get_xmm 1 va_sM) (va_get_xmm
15 va_sM), va_get_xmm 0 va_sM, va_get_xmm 5 va_sM, va_get_xmm 6 va_sM, va_get_xmm 7 va_sM,
va_get_xmm 3 va_sM)))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_mem_heaplet 6; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm
12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Loop6x_save_output count out_b va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Loop6x_save_output (va_code_Loop6x_save_output ()) va_s0 count
out_b in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 6 va_sM (va_update_xmm 14
va_sM (va_update_xmm 13 va_sM (va_update_xmm 12 va_sM (va_update_xmm 11 va_sM (va_update_xmm 10
va_sM (va_update_xmm 9 va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_mem_heaplet 6; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm
12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Loop6x_partial
#push-options "--z3rlimit 50 --max_ifuel 0"
[@ "opaque_to_smt" va_qattr]
let va_code_untransformedoriginal_Loop6x_partial alg =
(va_Block (va_CCons (va_code_Loop6x_preamble alg) (va_CCons (va_code_Loop6x_plain alg 0
(va_op_xmm_xmm 2)) (va_CCons (va_code_MulAdd_step 0 0 (va_op_xmm_xmm 1) (va_op_xmm_xmm 5)
(va_op_xmm_xmm 6) (va_op_xmm_xmm 7) (va_op_xmm_xmm 7) (va_op_xmm_xmm 3)) (va_CCons
(va_code_MulAdd_step 1 1 (va_op_xmm_xmm 5) (va_op_xmm_xmm 1) (va_op_xmm_xmm 2) (va_op_xmm_xmm
3) (va_op_xmm_xmm 0) (va_op_xmm_xmm 3)) (va_CCons (va_code_Loop6x_plain alg 1 (va_op_xmm_xmm
15)) (va_CCons (va_code_Loop6x_reverse128 5 2) (va_CCons (va_code_MulAdd_step 2 3
(va_op_xmm_xmm 1) (va_op_xmm_xmm 2) (va_op_xmm_xmm 3) (va_op_xmm_xmm 5) (va_op_xmm_xmm 0)
(va_op_xmm_xmm 5)) (va_CCons (va_code_Loop6x_plain alg 2 (va_op_xmm_xmm 15)) (va_CCons
(va_code_MulAdd_step 3 4 (va_op_xmm_xmm 2) (va_op_xmm_xmm 3) (va_op_xmm_xmm 5) (va_op_xmm_xmm
1) (va_op_xmm_xmm 0) (va_op_xmm_xmm 1)) (va_CCons (va_code_Loop6x_plain alg 3 (va_op_xmm_xmm
15)) (va_CCons (va_code_Loop6x_reverse128 4 3) (va_CCons (va_code_MulAdd_step 4 6
(va_op_xmm_xmm 3) (va_op_xmm_xmm 5) (va_op_xmm_xmm 1) (va_op_xmm_xmm 2) (va_op_xmm_xmm 0)
(va_op_xmm_xmm 2)) (va_CCons (va_code_Loop6x_plain alg 4 (va_op_xmm_xmm 15)) (va_CCons
(va_code_Loop6x_reverse128 3 4) (va_CCons (va_code_MulAdd_step 5 7 (va_op_xmm_xmm 2)
(va_op_xmm_xmm 5) (va_op_xmm_xmm 1) (va_op_xmm_xmm 8) (va_op_xmm_xmm 8) (va_op_xmm_xmm 3))
(va_CCons (va_code_Loop6x_plain alg 5 (va_op_xmm_xmm 15)) (va_CCons (va_code_Loop6x_reverse128
2 5) (va_CCons (va_code_Load_0xc2_msb (va_op_xmm_xmm 3)) (va_CCons (va_code_ReduceLast false)
(va_CCons (va_code_Loop6x_plain alg 6 (va_op_xmm_xmm 15)) (va_CCons (va_code_Loop6x_reverse128
1 6) (va_CCons (va_code_Loop6x_plain alg 7 (va_op_xmm_xmm 1)) (va_CCons
(va_code_LoadBe64_buffer128 (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rR13)
(va_op_reg_opr64_reg64 rR14) (0 `op_Multiply` 16 + 8) Secret true) (va_CCons
(va_code_LoadBe64_buffer128 (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rR12)
(va_op_reg_opr64_reg64 rR14) (0 `op_Multiply` 16) Secret false) (va_CCons (va_code_Loop6x_plain
alg 8 (va_op_xmm_xmm 15)) (va_CCons (if (alg = AES_256) then va_Block (va_CCons
(va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRcx) (160 - 128) Secret) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 9) (va_op_xmm_xmm 9)
(va_op_xmm_xmm 1)) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 10) (va_op_xmm_xmm 10)
(va_op_xmm_xmm 1)) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 11) (va_op_xmm_xmm 11)
(va_op_xmm_xmm 1)) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 12) (va_op_xmm_xmm 12)
(va_op_xmm_xmm 1)) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 13) (va_op_xmm_xmm 13)
(va_op_xmm_xmm 1)) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 14) (va_op_xmm_xmm 14)
(va_op_xmm_xmm 1)) (va_CCons (va_code_Loop6x_plain alg 10 (va_op_xmm_xmm 15)) (va_CCons
(va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRcx) (192 - 128) Secret) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 9) (va_op_xmm_xmm 9)
(va_op_xmm_xmm 1)) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 10) (va_op_xmm_xmm 10)
(va_op_xmm_xmm 1)) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 11) (va_op_xmm_xmm 11)
(va_op_xmm_xmm 1)) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 12) (va_op_xmm_xmm 12)
(va_op_xmm_xmm 1)) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 13) (va_op_xmm_xmm 13)
(va_op_xmm_xmm 1)) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 14) (va_op_xmm_xmm 14)
(va_op_xmm_xmm 1)) (va_CCons (va_code_Loop6x_plain alg 12 (va_op_xmm_xmm 15)) (va_CNil
()))))))))))))))))) else va_Block (va_CNil ())) (va_CCons (if (alg = AES_256) then va_Block
(va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1)
(va_op_reg_opr64_reg64 rRcx) (224 - 128) Secret) (va_CNil ())) else va_Block (va_CCons
(va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRcx) (160 - 128) Secret) (va_CNil ()))) (va_CCons (va_code_Loop6x_round9 alg) (va_CNil
()))))))))))))))))))))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_untransformedoriginal_Loop6x_partial alg =
(va_pbool_and (va_codegen_success_Loop6x_preamble alg) (va_pbool_and
(va_codegen_success_Loop6x_plain alg 0 (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_MulAdd_step 0 0 (va_op_xmm_xmm 1) (va_op_xmm_xmm 5) (va_op_xmm_xmm 6)
(va_op_xmm_xmm 7) (va_op_xmm_xmm 7) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_MulAdd_step 1 1 (va_op_xmm_xmm 5) (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)
(va_op_xmm_xmm 3) (va_op_xmm_xmm 0) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_Loop6x_plain alg 1 (va_op_xmm_xmm 15)) (va_pbool_and
(va_codegen_success_Loop6x_reverse128 5 2) (va_pbool_and (va_codegen_success_MulAdd_step 2 3
(va_op_xmm_xmm 1) (va_op_xmm_xmm 2) (va_op_xmm_xmm 3) (va_op_xmm_xmm 5) (va_op_xmm_xmm 0)
(va_op_xmm_xmm 5)) (va_pbool_and (va_codegen_success_Loop6x_plain alg 2 (va_op_xmm_xmm 15))
(va_pbool_and (va_codegen_success_MulAdd_step 3 4 (va_op_xmm_xmm 2) (va_op_xmm_xmm 3)
(va_op_xmm_xmm 5) (va_op_xmm_xmm 1) (va_op_xmm_xmm 0) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Loop6x_plain alg 3 (va_op_xmm_xmm 15)) (va_pbool_and
(va_codegen_success_Loop6x_reverse128 4 3) (va_pbool_and (va_codegen_success_MulAdd_step 4 6
(va_op_xmm_xmm 3) (va_op_xmm_xmm 5) (va_op_xmm_xmm 1) (va_op_xmm_xmm 2) (va_op_xmm_xmm 0)
(va_op_xmm_xmm 2)) (va_pbool_and (va_codegen_success_Loop6x_plain alg 4 (va_op_xmm_xmm 15))
(va_pbool_and (va_codegen_success_Loop6x_reverse128 3 4) (va_pbool_and
(va_codegen_success_MulAdd_step 5 7 (va_op_xmm_xmm 2) (va_op_xmm_xmm 5) (va_op_xmm_xmm 1)
(va_op_xmm_xmm 8) (va_op_xmm_xmm 8) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_Loop6x_plain alg 5 (va_op_xmm_xmm 15)) (va_pbool_and
(va_codegen_success_Loop6x_reverse128 2 5) (va_pbool_and (va_codegen_success_Load_0xc2_msb
(va_op_xmm_xmm 3)) (va_pbool_and (va_codegen_success_ReduceLast false) (va_pbool_and
(va_codegen_success_Loop6x_plain alg 6 (va_op_xmm_xmm 15)) (va_pbool_and
(va_codegen_success_Loop6x_reverse128 1 6) (va_pbool_and (va_codegen_success_Loop6x_plain alg 7
(va_op_xmm_xmm 1)) (va_pbool_and (va_codegen_success_LoadBe64_buffer128
(va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rR13) (va_op_reg_opr64_reg64 rR14) (0
`op_Multiply` 16 + 8) Secret true) (va_pbool_and (va_codegen_success_LoadBe64_buffer128
(va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rR12) (va_op_reg_opr64_reg64 rR14) (0
`op_Multiply` 16) Secret false) (va_pbool_and (va_codegen_success_Loop6x_plain alg 8
(va_op_xmm_xmm 15)) (va_pbool_and (if (alg = AES_256) then va_pbool_and
(va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1)
(va_op_reg_opr64_reg64 rRcx) (160 - 128) Secret) (va_pbool_and (va_codegen_success_VAESNI_enc
(va_op_xmm_xmm 9) (va_op_xmm_xmm 9) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_VAESNI_enc (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_xmm_xmm 1))
(va_pbool_and (va_codegen_success_VAESNI_enc (va_op_xmm_xmm 11) (va_op_xmm_xmm 11)
(va_op_xmm_xmm 1)) (va_pbool_and (va_codegen_success_VAESNI_enc (va_op_xmm_xmm 12)
(va_op_xmm_xmm 12) (va_op_xmm_xmm 1)) (va_pbool_and (va_codegen_success_VAESNI_enc
(va_op_xmm_xmm 13) (va_op_xmm_xmm 13) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_VAESNI_enc (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_xmm_xmm 1))
(va_pbool_and (va_codegen_success_Loop6x_plain alg 10 (va_op_xmm_xmm 15)) (va_pbool_and
(va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1)
(va_op_reg_opr64_reg64 rRcx) (192 - 128) Secret) (va_pbool_and (va_codegen_success_VAESNI_enc
(va_op_xmm_xmm 9) (va_op_xmm_xmm 9) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_VAESNI_enc (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_xmm_xmm 1))
(va_pbool_and (va_codegen_success_VAESNI_enc (va_op_xmm_xmm 11) (va_op_xmm_xmm 11)
(va_op_xmm_xmm 1)) (va_pbool_and (va_codegen_success_VAESNI_enc (va_op_xmm_xmm 12)
(va_op_xmm_xmm 12) (va_op_xmm_xmm 1)) (va_pbool_and (va_codegen_success_VAESNI_enc
(va_op_xmm_xmm 13) (va_op_xmm_xmm 13) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_VAESNI_enc (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_xmm_xmm 1))
(va_pbool_and (va_codegen_success_Loop6x_plain alg 12 (va_op_xmm_xmm 15)) (va_ttrue
())))))))))))))))) else va_ttrue ()) (va_pbool_and (if (alg = AES_256) then va_pbool_and
(va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1)
(va_op_reg_opr64_reg64 rRcx) (224 - 128) Secret) (va_ttrue ()) else va_pbool_and
(va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1)
(va_op_reg_opr64_reg64 rRcx) (160 - 128) Secret) (va_ttrue ())) (va_pbool_and
(va_codegen_success_Loop6x_round9 alg) (va_ttrue ())))))))))))))))))))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_untransformedoriginal_Loop6x_partial (va_mods:va_mods_t) (alg:algorithm) (h_LE:quad32)
(y_prev:quad32) (data:(seq quad32)) (count:nat) (in0_count:nat) (iv_b:buffer128)
(in0_b:buffer128) (in_b:buffer128) (scratch_b:buffer128) (key_words:(seq nat32)) (round_keys:(seq
quad32)) (keys_b:buffer128) (hkeys_b:buffer128) (ctr_BE:quad32) : (va_quickCode (quad32_6)
(va_code_untransformedoriginal_Loop6x_partial alg)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in let
(h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in let (prev:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (Vale.Def.Types_s.reverse_bytes_quad32 y_prev) in let
(init:quad32_6) = make_six_of #Vale.Def.Types_s.quad32 (fun (n:(va_int_range 0 5)) ->
Vale.Def.Types_s.quad32_xor (Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite
ctr_BE n)) (va_get_xmm 15 va_s)) in let (start:(va_int_at_least 0)) = in0_count `op_Multiply` 6
in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 871 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_preamble alg h_LE iv_b scratch_b key_words round_keys keys_b hkeys_b ctr_BE)
(va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 872 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 0 key_words round_keys keys_b init (va_op_xmm_xmm 2)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 873 column 16 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_MulAdd_step 0 0 (va_op_xmm_xmm 1) (va_op_xmm_xmm 5) (va_op_xmm_xmm 6) (va_op_xmm_xmm
7) (va_op_xmm_xmm 7) (va_op_xmm_xmm 3) hkeys_b scratch_b h prev data) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 874 column 16 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_MulAdd_step 1 1 (va_op_xmm_xmm 5) (va_op_xmm_xmm 1) (va_op_xmm_xmm 2) (va_op_xmm_xmm
3) (va_op_xmm_xmm 0) (va_op_xmm_xmm 3) hkeys_b scratch_b h prev data) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 875 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 1 key_words round_keys keys_b init (va_op_xmm_xmm 15)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 876 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_reverse128 5 2 start in0_b scratch_b) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 877 column 16 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_MulAdd_step 2 3 (va_op_xmm_xmm 1) (va_op_xmm_xmm 2) (va_op_xmm_xmm 3) (va_op_xmm_xmm
5) (va_op_xmm_xmm 0) (va_op_xmm_xmm 5) hkeys_b scratch_b h prev data) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 878 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 2 key_words round_keys keys_b init (va_op_xmm_xmm 15)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 879 column 16 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_MulAdd_step 3 4 (va_op_xmm_xmm 2) (va_op_xmm_xmm 3) (va_op_xmm_xmm 5) (va_op_xmm_xmm
1) (va_op_xmm_xmm 0) (va_op_xmm_xmm 1) hkeys_b scratch_b h prev data) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 880 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 3 key_words round_keys keys_b init (va_op_xmm_xmm 15)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 881 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_reverse128 4 3 start in0_b scratch_b) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 882 column 16 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_MulAdd_step 4 6 (va_op_xmm_xmm 3) (va_op_xmm_xmm 5) (va_op_xmm_xmm 1) (va_op_xmm_xmm
2) (va_op_xmm_xmm 0) (va_op_xmm_xmm 2) hkeys_b scratch_b h prev data) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 883 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 4 key_words round_keys keys_b init (va_op_xmm_xmm 15)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 884 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_reverse128 3 4 start in0_b scratch_b) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 885 column 16 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_MulAdd_step 5 7 (va_op_xmm_xmm 2) (va_op_xmm_xmm 5) (va_op_xmm_xmm 1) (va_op_xmm_xmm
8) (va_op_xmm_xmm 8) (va_op_xmm_xmm 3) hkeys_b scratch_b h prev data) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 886 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 5 key_words round_keys keys_b init (va_op_xmm_xmm 15)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 887 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_reverse128 2 5 start in0_b scratch_b) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 888 column 18 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load_0xc2_msb (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 891 column 15 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_ReduceLast false h_LE y_prev data) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 892 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 6 key_words round_keys keys_b init (va_op_xmm_xmm 15)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 893 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_reverse128 1 6 start in0_b scratch_b) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 894 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 7 key_words round_keys keys_b init (va_op_xmm_xmm 1)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 895 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_LoadBe64_buffer128 (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rR13)
(va_op_reg_opr64_reg64 rR14) (0 `op_Multiply` 16 + 8) Secret true in0_b (in0_count
`op_Multiply` 6 + 0)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 896 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_LoadBe64_buffer128 (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rR12)
(va_op_reg_opr64_reg64 rR14) (0 `op_Multiply` 16) Secret false in0_b (in0_count `op_Multiply` 6
+ 0)) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 897 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 8 key_words round_keys keys_b init (va_op_xmm_xmm 15)) (fun
(va_s:va_state) _ -> va_QBind va_range1
"***** PRECONDITION NOT MET AT line 901 column 15 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_qInlineIf va_mods (alg = AES_256) (qblock va_mods (fun (va_s:va_state) -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 913 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRcx) (160 - 128) Secret keys_b 10) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 914 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 9) (va_op_xmm_xmm 9) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 915 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_xmm_xmm 1)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 916 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_xmm_xmm 1)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 917 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 12) (va_op_xmm_xmm 12) (va_op_xmm_xmm 1)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 918 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 13) (va_op_xmm_xmm 13) (va_op_xmm_xmm 1)) (va_QBind
va_range1
"***** PRECONDITION NOT MET AT line 919 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_xmm_xmm 1)) (fun
(va_s:va_state) _ -> va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 921 column 27 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_s.eval_rounds_reveal ()) (va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 922 column 44 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.commute_sub_bytes_shift_rows_forall ()) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 923 column 21 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 10 key_words round_keys keys_b init (va_op_xmm_xmm 15)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 926 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRcx) (192 - 128) Secret keys_b 12) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 927 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 9) (va_op_xmm_xmm 9) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 928 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_xmm_xmm 1)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 929 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_xmm_xmm 1)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 930 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 12) (va_op_xmm_xmm 12) (va_op_xmm_xmm 1)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 931 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 13) (va_op_xmm_xmm 13) (va_op_xmm_xmm 1)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 932 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_xmm_xmm 1)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 934 column 21 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 12 key_words round_keys keys_b init (va_op_xmm_xmm 15)) (va_QEmpty
(()))))))))))))))))))))) (qblock va_mods (fun (va_s:va_state) -> va_QEmpty (())))) (fun
(va_s:va_state) va_g -> va_QBind va_range1
"***** PRECONDITION NOT MET AT line 937 column 15 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_qInlineIf va_mods (alg = AES_256) (qblock va_mods (fun (va_s:va_state) -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 939 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRcx) (224 - 128) Secret keys_b 14) (va_QEmpty (())))) (qblock va_mods (fun (va_s:va_state) ->
va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 943 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRcx) (160 - 128) Secret keys_b 10) (va_QEmpty (()))))) (fun (va_s:va_state) va_g -> va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 946 column 18 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_round9 alg count in_b scratch_b key_words round_keys keys_b) (va_QEmpty
((init))))))))))))))))))))))))))))))))
[@"opaque_to_smt"]
let va_lemma_untransformedoriginal_Loop6x_partial va_b0 va_s0 alg h_LE y_prev data count in0_count
iv_b in0_b in_b scratch_b key_words round_keys keys_b hkeys_b ctr_BE =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_mem_heaplet 3; va_Mod_mem_heaplet 2; va_Mod_xmm
15; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9;
va_Mod_xmm 8; va_Mod_xmm 7; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 4; va_Mod_xmm 3; va_Mod_xmm
2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_reg64 rR11;
va_Mod_reg64 rRbx; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_untransformedoriginal_Loop6x_partial va_mods alg h_LE y_prev data count
in0_count iv_b in0_b in_b scratch_b key_words round_keys keys_b hkeys_b ctr_BE in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_untransformedoriginal_Loop6x_partial
alg) va_qc va_s0 (fun va_s0 va_sM va_g -> let init = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 758 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_ok va_sM) /\ (let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in let (prev:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (Vale.Def.Types_s.reverse_bytes_quad32 y_prev) in label
va_range1
"***** POSTCONDITION NOT MET AT line 837 column 72 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 scratch_b (va_get_mem_heaplet 3 va_s0)
(va_get_mem_heaplet 3 va_sM) 1 8) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 838 column 70 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 iv_b (va_get_mem_heaplet 2 va_s0)
(va_get_mem_heaplet 2 va_sM) 0 0) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 843 column 27 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(0 <= va_get_reg64 rRbx va_sM /\ va_get_reg64 rRbx va_sM < 256) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 844 column 50 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_reg64 rRbx va_sM == Vale.Def.Words_s.__proj__Mkfour__item__lo0 (Vale.AES.GCTR.inc32lite
ctr_BE 6) `op_Modulus` 256) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 847 column 118 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM, va_get_xmm
13 va_sM, va_get_xmm 14 va_sM) == rounds_opaque_6 init round_keys (Vale.AES.AES_common_s.nr alg
- 1)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 848 column 90 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_reg64 rR13 va_sM == Vale.Def.Types_s.reverse_bytes_nat64 (Vale.Arch.Types.hi64
(Vale.X64.Decls.buffer128_read in0_b (in0_count `op_Multiply` 6 + 0) (va_get_mem_heaplet 6
va_sM)))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 849 column 90 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_reg64 rR12 va_sM == Vale.Def.Types_s.reverse_bytes_nat64 (Vale.Arch.Types.lo64
(Vale.X64.Decls.buffer128_read in0_b (in0_count `op_Multiply` 6 + 0) (va_get_mem_heaplet 6
va_sM)))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 850 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(let rk = FStar.Seq.Base.index #quad32 round_keys (Vale.AES.AES_common_s.nr alg) in label
va_range1
"***** POSTCONDITION NOT MET AT line 852 column 107 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((va_get_xmm 2 va_sM, va_get_xmm 0 va_sM, va_get_xmm 5 va_sM, va_get_xmm 6 va_sM, va_get_xmm 7
va_sM, va_get_xmm 3 va_sM) == make_six_of #quad32 (fun (i:(va_int_range 0 5)) ->
Vale.Def.Types_s.quad32_xor rk (Vale.X64.Decls.buffer128_read in_b (count `op_Multiply` 6 + i)
(va_get_mem_heaplet 6 va_sM)))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 853 column 90 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 8 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 6)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 857 column 122 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 2 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b (in0_count
`op_Multiply` 6 + 5) (va_get_mem_heaplet 6 va_s0))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 858 column 122 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 3 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b (in0_count
`op_Multiply` 6 + 4) (va_get_mem_heaplet 6 va_s0))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 859 column 122 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 4 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b (in0_count
`op_Multiply` 6 + 3) (va_get_mem_heaplet 6 va_s0))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 860 column 122 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 5 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b (in0_count
`op_Multiply` 6 + 2) (va_get_mem_heaplet 6 va_s0))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 861 column 122 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 6 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b (in0_count
`op_Multiply` 6 + 1) (va_get_mem_heaplet 6 va_s0))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 863 column 90 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(init == make_six_of #quad32 (fun (n:(va_int_range 0 5)) -> Vale.Def.Types_s.quad32_xor
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE n))
(FStar.Seq.Base.index #Vale.Def.Types_s.quad32 round_keys 0))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 864 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(let eventual_Xi = add (add (Vale.Math.Poly2.Bits_s.of_quad32 (va_get_xmm 8 va_sM))
(Vale.Math.Poly2.Bits_s.of_quad32 (Vale.X64.Decls.buffer128_read scratch_b 1
(va_get_mem_heaplet 3 va_sM)))) (Vale.Math.Poly2.Bits_s.of_quad32 (va_get_xmm 4 va_sM)) in
label va_range1
"***** POSTCONDITION NOT MET AT line 865 column 94 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(eventual_Xi == Vale.Math.Poly2.Bits_s.of_quad32 (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.AES.GHash.ghash_incremental h_LE y_prev data))))))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_mem_heaplet 3; va_Mod_mem_heaplet 2; va_Mod_xmm 15;
va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9;
va_Mod_xmm 8; va_Mod_xmm 7; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 4; va_Mod_xmm 3; va_Mod_xmm
2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_reg64 rR11;
va_Mod_reg64 rRbx; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
let init = va_g in
(va_sM, va_fM, init)
[@ "opaque_to_smt" va_qattr]
let va_transform_Loop6x_partial alg =
(reorder (va_code_untransformedoriginal_Loop6x_partial alg) (va_code_Loop6x_partial_expected_code
alg))
[@ "opaque_to_smt" va_qattr]
let va_code_Loop6x_partial alg =
(va_get_result (va_transform_Loop6x_partial alg))
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_Loop6x_partial alg =
(va_pbool_and (va_codegen_success_untransformedoriginal_Loop6x_partial alg) (va_get_success
(va_transform_Loop6x_partial alg)))
[@"opaque_to_smt"]
let va_lemma_Loop6x_partial va_b0 va_s0 alg h_LE y_prev data count in0_count iv_b in0_b in_b
scratch_b key_words round_keys keys_b hkeys_b ctr_BE =
let va_orig = va_code_untransformedoriginal_Loop6x_partial alg in
let va_hint = va_code_Loop6x_partial_expected_code alg in
let va_transformed = va_code_Loop6x_partial alg in
let (va_sM_orig, va_fM_orig, init) = va_lemma_untransformedoriginal_Loop6x_partial va_orig va_s0
alg h_LE y_prev data count in0_count iv_b in0_b in_b scratch_b key_words round_keys keys_b
hkeys_b ctr_BE in
va_reveal_opaque (`%va_transform_Loop6x_partial) (va_transform_Loop6x_partial alg);
va_reveal_opaque (`%va_code_Loop6x_partial) (va_code_Loop6x_partial alg);
let (va_sM, va_fM) = lemma_reorder va_orig va_hint va_transformed va_s0 va_sM_orig va_fM_orig in
(va_sM, va_fM, init)
[@"opaque_to_smt"]
let va_wpProof_Loop6x_partial alg h_LE y_prev data count in0_count iv_b in0_b in_b scratch_b
key_words round_keys keys_b hkeys_b ctr_BE va_s0 va_k =
let (va_sM, va_f0, init) = va_lemma_Loop6x_partial (va_code_Loop6x_partial alg) va_s0 alg h_LE
y_prev data count in0_count iv_b in0_b in_b scratch_b key_words round_keys keys_b hkeys_b
ctr_BE in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 3 va_sM
(va_update_mem_heaplet 2 va_sM (va_update_xmm 15 va_sM (va_update_xmm 14 va_sM (va_update_xmm
13 va_sM (va_update_xmm 12 va_sM (va_update_xmm 11 va_sM (va_update_xmm 10 va_sM (va_update_xmm
9 va_sM (va_update_xmm 8 va_sM (va_update_xmm 7 va_sM (va_update_xmm 6 va_sM (va_update_xmm 5
va_sM (va_update_xmm 4 va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1
va_sM (va_update_xmm 0 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR12 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rRbx va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0))))))))))))))))))))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_mem_heaplet 3; va_Mod_mem_heaplet 2; va_Mod_xmm 15;
va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9;
va_Mod_xmm 8; va_Mod_xmm 7; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 4; va_Mod_xmm 3; va_Mod_xmm
2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_reg64 rR11;
va_Mod_reg64 rRbx; va_Mod_mem]) va_sM va_s0;
let va_g = (init) in
(va_sM, va_f0, va_g)
#pop-options
//--
//-- Loop6x
#push-options "--z3rlimit 100"
[@ "opaque_to_smt" va_qattr]
let va_code_Loop6x alg =
(va_Block (va_CCons (va_Block (va_CNil ())) (va_CCons (va_Block (va_CNil ())) (va_CCons
(va_code_Loop6x_partial alg) (va_CCons (va_code_Loop6x_final alg) (va_CCons (va_code_Sub64
(va_op_dst_opr64_reg64 rRdx) (va_const_opr64 6)) (va_CCons (va_code_Add64
(va_op_dst_opr64_reg64 rR14) (va_const_opr64 96)) (va_CCons (va_Block (va_CNil ())) (va_CCons
(va_Block (va_CNil ())) (va_CCons (va_Block (va_CNil ())) (va_CCons (va_Block (va_CNil ()))
(va_CCons (va_IfElse (va_cmp_gt (va_op_cmp_reg64 rRdx) (va_const_cmp 0)) (va_Block (va_CCons
(va_code_Loop6x_save_output ()) (va_CCons (va_Block (va_CNil ())) (va_CCons
(va_code_Load128_buffer (va_op_heaplet_mem_heaplet 3) (va_op_xmm_xmm 7) (va_op_reg_opr64_reg64
rRbp) 32 Secret) (va_CCons (va_Block (va_CNil ())) (va_CNil ())))))) (va_Block (va_CCons
(va_code_Mem128_lemma ()) (va_CCons (va_code_VPolyAdd (va_op_xmm_xmm 8) (va_op_xmm_xmm 8)
(va_opr_code_Mem128 (va_op_heaplet_mem_heaplet 3) (va_op_reg64_reg64 rRbp) 16 Secret))
(va_CCons (va_code_VPolyAdd (va_op_xmm_xmm 8) (va_op_xmm_xmm 8) (va_op_opr128_xmm 4)) (va_CNil
())))))) (va_CNil ())))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_Loop6x alg =
(va_pbool_and (va_codegen_success_Loop6x_partial alg) (va_pbool_and
(va_codegen_success_Loop6x_final alg) (va_pbool_and (va_codegen_success_Sub64
(va_op_dst_opr64_reg64 rRdx) (va_const_opr64 6)) (va_pbool_and (va_codegen_success_Add64
(va_op_dst_opr64_reg64 rR14) (va_const_opr64 96)) (va_pbool_and (va_pbool_and
(va_codegen_success_Loop6x_save_output ()) (va_pbool_and (va_codegen_success_Load128_buffer
(va_op_heaplet_mem_heaplet 3) (va_op_xmm_xmm 7) (va_op_reg_opr64_reg64 rRbp) 32 Secret)
(va_pbool_and (va_codegen_success_Mem128_lemma ()) (va_pbool_and (va_codegen_success_VPolyAdd
(va_op_xmm_xmm 8) (va_op_xmm_xmm 8) (va_opr_code_Mem128 (va_op_heaplet_mem_heaplet 3)
(va_op_reg64_reg64 rRbp) 16 Secret)) (va_codegen_success_VPolyAdd (va_op_xmm_xmm 8)
(va_op_xmm_xmm 8) (va_op_opr128_xmm 4)))))) (va_ttrue ())))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.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.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Transformers.Transform.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.AES.X64.PolyOps.fsti.checked",
"Vale.AES.X64.AESopt2.fsti.checked",
"Vale.AES.X64.AESGCM_expected_code.fsti.checked",
"Vale.AES.GHash.fsti.checked",
"Vale.AES.GF128_s.fsti.checked",
"Vale.AES.GF128.fsti.checked",
"Vale.AES.GCTR_s.fst.checked",
"Vale.AES.GCTR.fsti.checked",
"Vale.AES.GCM_helpers.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.AES.X64.AESopt.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Transform",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64.AESGCM_expected_code",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64.AESopt2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64.PolyOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GHash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCM_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"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.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"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.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_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": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Transform",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64.AESGCM_expected_code",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64.AESopt2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64.PolyOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GHash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCM_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"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.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"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.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_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": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.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
}
] | {
"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": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_mods: Vale.X64.QuickCode.va_mods_t ->
alg: Vale.AES.AES_common_s.algorithm ->
h_LE: Vale.X64.Decls.quad32 ->
y_orig: Vale.X64.Decls.quad32 ->
y_prev: Vale.X64.Decls.quad32 ->
count: Prims.nat ->
iv_b: Vale.X64.Memory.buffer128 ->
in0_b: Vale.X64.Memory.buffer128 ->
in_b: Vale.X64.Memory.buffer128 ->
out_b: Vale.X64.Memory.buffer128 ->
scratch_b: Vale.X64.Memory.buffer128 ->
plain_quads: FStar.Seq.Base.seq Vale.X64.Decls.quad32 ->
key_words: FStar.Seq.Base.seq Vale.X64.Memory.nat32 ->
round_keys: FStar.Seq.Base.seq Vale.X64.Decls.quad32 ->
keys_b: Vale.X64.Memory.buffer128 ->
hkeys_b: Vale.X64.Memory.buffer128 ->
ctr_BE_orig: Vale.X64.Decls.quad32 ->
ctr_BE: Vale.X64.Decls.quad32
-> Vale.X64.QuickCode.va_quickCode Vale.X64.Decls.quad32 (Vale.AES.X64.AESopt.va_code_Loop6x alg) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCode.va_mods_t",
"Vale.AES.AES_common_s.algorithm",
"Vale.X64.Decls.quad32",
"Prims.nat",
"Vale.X64.Memory.buffer128",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat32",
"Vale.X64.QuickCodes.qblock",
"Vale.Def.Types_s.quad32",
"Prims.Cons",
"Vale.X64.Decls.va_code",
"Vale.X64.Machine_s.Block",
"Vale.X64.Decls.ins",
"Vale.X64.Decls.ocmp",
"Prims.Nil",
"Vale.X64.Machine_s.precode",
"Vale.AES.X64.AESopt.va_code_Loop6x_partial",
"Vale.AES.X64.AESopt.va_code_Loop6x_final",
"Vale.X64.InsBasic.va_code_Sub64",
"Vale.X64.Decls.va_op_dst_opr64_reg64",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Decls.va_const_opr64",
"Vale.X64.InsBasic.va_code_Add64",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.IfElse",
"Vale.X64.QuickCodes.cmp_to_ocmp",
"Vale.X64.QuickCodes.Cmp_gt",
"Vale.X64.Decls.va_op_cmp_reg64",
"Vale.X64.Decls.va_const_cmp",
"Vale.X64.QuickCodes.block",
"Vale.AES.X64.AESopt.va_code_Loop6x_save_output",
"Vale.X64.InsVector.va_code_Load128_buffer",
"Vale.X64.Decls.va_op_heaplet_mem_heaplet",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.Decls.va_op_reg_opr64_reg64",
"Vale.X64.Machine_s.rRbp",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.InsVector.va_code_Mem128_lemma",
"Vale.AES.X64.PolyOps.va_code_VPolyAdd",
"Vale.X64.Decls.va_opr_code_Mem128",
"Vale.X64.Decls.va_op_reg64_reg64",
"Vale.X64.Decls.va_op_opr128_xmm",
"Vale.X64.Decls.va_state",
"Vale.X64.QuickCodes.va_qAssertSquash",
"Vale.X64.QuickCodes.va_range1",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_Subtraction",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_Multiply",
"FStar.Seq.Base.length",
"Vale.X64.Decls.s128",
"Vale.X64.Decls.va_get_mem_heaplet",
"Prims.op_Addition",
"Prims.squash",
"Vale.X64.QuickCodes.va_qPURE",
"Prims.pure_post",
"Prims.unit",
"Prims.op_LessThan",
"Vale.Math.Poly2_s.degree",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.eq2",
"Vale.Math.Poly2_s.poly",
"Vale.Math.Poly2.Bits_s.of_quad32",
"Vale.Math.Poly2.Bits_s.to_quad32",
"Vale.Math.Poly2.Bits.lemma_of_to_quad32",
"Vale.X64.QuickCodes.va_QBind",
"Vale.AES.X64.AESopt.quad32_6",
"Vale.AES.X64.AESopt.va_quick_Loop6x_partial",
"Vale.X64.QuickCodes.va_QSeq",
"Vale.AES.X64.AESopt.va_quick_Loop6x_final",
"Vale.AES.GCTR.inc32lite",
"Vale.X64.Decls.buffer128_read",
"Vale.X64.InsBasic.va_quick_Sub64",
"Vale.X64.InsBasic.va_quick_Add64",
"Prims.op_Equality",
"Vale.AES.GHash.ghash_incremental0",
"FStar.Seq.Base.op_At_Bar",
"Vale.AES.GHash.lemma_ghash_incremental0_append",
"Vale.X64.QuickCodes.va_qAssert",
"FStar.Seq.Base.append",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.equal",
"Vale.X64.QuickCodes.va_qIf",
"Vale.AES.X64.AESopt.va_quick_Loop6x_save_output",
"Vale.X64.InsVector.va_quick_Load128_buffer",
"Vale.AES.AES_s.is_aes_key_LE",
"Prims.l_iff",
"Vale.AES.GCTR.gctr_partial",
"Vale.AES.GCTR.gctr_partial_opaque_ignores_postfix",
"FStar.Seq.Base.index",
"Vale.Def.Types_s.quad32_xor",
"Vale.AES.GCTR.aes_encrypt_BE",
"Vale.AES.GCTR.gctr_partial_extend6",
"Prims.l_True",
"Vale.Math.Poly2_s.add",
"Vale.AES.GHash.lemma_add_manip",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Vale.AES.GHash.ghash_incremental",
"Vale.X64.QuickCodes.va_QEmpty",
"Vale.X64.Decls.va_get_xmm",
"Vale.Def.Words_s.nat32",
"Vale.X64.Decls.buffer128_as_seq",
"Vale.X64.QuickCodes.quickCodes",
"Vale.X64.Decls.va_int_at_least",
"Vale.X64.InsVector.va_quick_Mem128_lemma",
"Vale.AES.X64.PolyOps.va_quick_VPolyAdd",
"Prims.int",
"Vale.Def.Prop_s.prop0",
"Vale.AES.GCTR.gctr_registers",
"Vale.AES.GCTR.gctr_registers_def",
"Vale.AES.GCTR.gctr_registers_reveal",
"Vale.Arch.HeapImpl.vale_heap",
"Vale.AES.X64.AESopt.six_of",
"Vale.AES.X64.AESopt.make_six_of",
"Vale.X64.Decls.va_int_range",
"Vale.AES.X64.AESopt.add",
"Vale.X64.State.vale_state",
"Vale.X64.QuickCode.va_quickCode",
"Vale.AES.X64.AESopt.va_code_Loop6x"
] | [] | false | false | false | false | false | let va_qcode_Loop6x
(va_mods: va_mods_t)
(alg: algorithm)
(h_LE y_orig y_prev: quad32)
(count: nat)
(iv_b in0_b in_b out_b scratch_b: buffer128)
(plain_quads: (seq quad32))
(key_words: (seq nat32))
(round_keys: (seq quad32))
(keys_b hkeys_b: buffer128)
(ctr_BE_orig ctr_BE: quad32)
: (va_quickCode (quad32) (va_code_Loop6x alg)) =
| (qblock va_mods
(fun (va_s: va_state) ->
let va_old_s:va_state = va_s in
let prev:Vale.Math.Poly2_s.poly =
add (add (Vale.Math.Poly2.Bits_s.of_quad32 (va_get_xmm 8 va_s))
(Vale.Math.Poly2.Bits_s.of_quad32 (va_get_xmm 4 va_s)))
(Vale.Math.Poly2.Bits_s.of_quad32 (Vale.X64.Decls.buffer128_read scratch_b
1
(va_get_mem_heaplet 3 va_s)))
in
let y_prev:Vale.Def.Types_s.quad32 =
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.Math.Poly2.Bits_s.to_quad32 prev)
in
va_qAssertSquash va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 1100 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(count - 2 >= 0 /\ count - 2 >= 0 /\
(fun
a_1906
(s_1907: (FStar.Seq.Base.seq a_1906))
(i_1908: Prims.nat)
(j_1909: Prims.nat)
->
let j_1869:Prims.nat = j_1909 in
Prims.b2t (Prims.op_AmpAmp (Prims.op_LessThanOrEqual i_1908 j_1869)
(Prims.op_LessThanOrEqual j_1869 (FStar.Seq.Base.length #a_1906 s_1907)))) Vale.X64.Decls.quad32
(Vale.X64.Decls.s128 (va_get_mem_heaplet 6 va_s) in0_b)
((count - 2) `op_Multiply` 6)
((count - 2) `op_Multiply` 6 + 6))
(fun _ ->
let data:(FStar.Seq.Base.seq Vale.X64.Decls.quad32) =
FStar.Seq.Base.slice #Vale.X64.Decls.quad32
(Vale.X64.Decls.s128 (va_get_mem_heaplet 6 va_s) in0_b)
((count - 2) `op_Multiply` 6)
((count - 2) `op_Multiply` 6 + 6)
in
va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 1101 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_: unit) -> Vale.Math.Poly2.Bits.lemma_of_to_quad32 prev)
(va_qAssertSquash va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 1103 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(count - 1 >= 0)
(fun _ ->
va_QBind va_range1
"***** PRECONDITION NOT MET AT line 1103 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_partial alg h_LE y_prev data count (count - 1) iv_b in0_b
in_b scratch_b key_words round_keys keys_b hkeys_b ctr_BE)
(fun (va_s: va_state) (init: quad32_6) ->
let ctrs:(six_of Vale.Def.Types_s.quad32) =
make_six_of #Vale.Def.Types_s.quad32
(fun (i: (va_int_range 0 5)) ->
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite
ctr_BE
i))
in
let plains:(six_of Vale.X64.Decls.quad32) =
make_six_of #Vale.X64.Decls.quad32
(fun (i: (va_int_range 0 5)) ->
Vale.X64.Decls.buffer128_read in_b
(count `op_Multiply` 6 + i)
(va_get_mem_heaplet 6 va_s))
in
va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 1108 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_final alg iv_b scratch_b key_words round_keys
keys_b (Vale.AES.GCTR.inc32lite ctr_BE 6) init ctrs plains
(Vale.X64.Decls.buffer128_read in0_b
((count - 1) `op_Multiply` 6 + 0)
(va_get_mem_heaplet 6 va_s)))
(va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 1111 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Sub64 (va_op_dst_opr64_reg64 rRdx) (va_const_opr64 6))
(va_QBind va_range1
"***** PRECONDITION NOT MET AT line 1112 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Add64 (va_op_dst_opr64_reg64 rR14)
(va_const_opr64 96))
(fun (va_s: va_state) _ ->
let y_new:quad32 =
Vale.AES.GHash.ghash_incremental0 h_LE y_prev data
in
let mem_snap:vale_heap = va_get_mem_heaplet 6 va_s in
va_qAssertSquash va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 1116 column 36 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(count - 2 >= 0 /\
(fun
a_1906
(s_1907: (FStar.Seq.Base.seq a_1906))
(i_1908: Prims.nat)
(j_1909: Prims.nat)
->
let j_1869:Prims.nat = j_1909 in
Prims.b2t (Prims.op_AmpAmp (Prims.op_LessThanOrEqual
i_1908
j_1869)
(Prims.op_LessThanOrEqual j_1869
(FStar.Seq.Base.length #a_1906 s_1907)
))) Vale.X64.Decls.quad32
(Vale.X64.Decls.s128 (va_get_mem_heaplet 6 va_s)
in0_b)
0
((count - 2) `op_Multiply` 6))
(fun _ ->
let va_arg93:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32
) =
data
in
let va_arg92:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32
) =
FStar.Seq.Base.slice #Vale.X64.Decls.quad32
(Vale.X64.Decls.s128 (va_get_mem_heaplet 6
va_s)
in0_b)
0
((count - 2) `op_Multiply` 6)
in
let va_arg91:Vale.Def.Types_s.quad32 = y_new in
let va_arg90:Vale.Def.Types_s.quad32 = y_orig in
let va_arg89:Vale.Def.Types_s.quad32 = h_LE in
va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 1116 column 36 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_: unit) ->
Vale.AES.GHash.lemma_ghash_incremental0_append
va_arg89
va_arg90
y_prev
va_arg91
va_arg92
va_arg93)
(va_qAssertSquash va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 1117 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(count - 2 >= 0 /\
(fun
a_1906
(s_1907: (FStar.Seq.Base.seq a_1906))
(i_1908: Prims.nat)
(j_1909: Prims.nat)
->
let j_1869:Prims.nat = j_1909 in
Prims.b2t (Prims.op_AmpAmp (Prims.op_LessThanOrEqual
i_1908
j_1869)
(Prims.op_LessThanOrEqual j_1869
(FStar.Seq.Base.length #a_1906
s_1907)))) Vale.X64.Decls.quad32
(Vale.X64.Decls.s128 (va_get_mem_heaplet
6
va_s)
in0_b)
0
((count - 2) `op_Multiply` 6))
(fun _ ->
va_qAssert va_range1
"***** PRECONDITION NOT MET AT line 1117 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(y_new ==
Vale.AES.GHash.ghash_incremental0 h_LE
y_orig
(FStar.Seq.Base.append #Vale.X64.Decls.quad32
(FStar.Seq.Base.slice #Vale.X64.Decls.quad32
(Vale.X64.Decls.s128 (va_get_mem_heaplet
6
va_s)
in0_b)
0
((count - 2)
`op_Multiply`
6))
data))
(va_qAssertSquash va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 1118 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(count - 2 >= 0 /\
(fun
a_1906
(s_1907:
(FStar.Seq.Base.seq a_1906
))
(i_1908: Prims.nat)
(j_1909: Prims.nat)
->
let j_1869:Prims.nat =
j_1909
in
Prims.b2t (Prims.op_AmpAmp (Prims.op_LessThanOrEqual
i_1908
j_1869)
(Prims.op_LessThanOrEqual
j_1869
(FStar.Seq.Base.length
#a_1906
s_1907)))) Vale.X64.Decls.quad32
(Vale.X64.Decls.s128 (va_get_mem_heaplet
6
va_s)
in0_b)
0
((count - 2) `op_Multiply` 6) /\
count - 1 >= 0 /\
(fun
a_1906
(s_1907:
(FStar.Seq.Base.seq a_1906
))
(i_1908: Prims.nat)
(j_1909: Prims.nat)
->
let j_1869:Prims.nat =
j_1909
in
Prims.b2t (Prims.op_AmpAmp (Prims.op_LessThanOrEqual
i_1908
j_1869)
(Prims.op_LessThanOrEqual
j_1869
(FStar.Seq.Base.length
#a_1906
s_1907)))) Vale.X64.Decls.quad32
(Vale.X64.Decls.s128 (va_get_mem_heaplet
6
va_s)
in0_b)
0
((count - 1) `op_Multiply` 6))
(fun _ ->
va_qAssert va_range1
"***** PRECONDITION NOT MET AT line 1118 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(FStar.Seq.Base.equal #Vale.X64.Decls.quad32
(FStar.Seq.Base.append #Vale.X64.Decls.quad32
(FStar.Seq.Base.slice
#Vale.X64.Decls.quad32
(Vale.X64.Decls.s128
(va_get_mem_heaplet
6
va_s)
in0_b)
0
((count - 2)
`op_Multiply`
6))
data)
(FStar.Seq.Base.slice #Vale.X64.Decls.quad32
(Vale.X64.Decls.s128
(va_get_mem_heaplet
6
va_s)
in0_b)
0
((count - 1)
`op_Multiply`
6)))
(va_qAssertSquash va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 1121 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(count - 1 >= 0 /\
(fun
a_1906
(s_1907:
(FStar.Seq.Base.seq
a_1906))
(i_1908:
Prims.nat)
(j_1909:
Prims.nat)
->
let j_1869:Prims.nat
=
j_1909
in
Prims.b2t (Prims.op_AmpAmp
(Prims.op_LessThanOrEqual
i_1908
j_1869)
(Prims.op_LessThanOrEqual
j_1869
(FStar.Seq.Base.length
#a_1906
s_1907
)))) Vale.X64.Decls.quad32
(Vale.X64.Decls.s128
(va_get_mem_heaplet
6
va_s)
in0_b)
0
((count - 1)
`op_Multiply`
6))
(fun _ ->
va_qAssert va_range1
"***** PRECONDITION NOT MET AT line 1121 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(y_new ==
Vale.AES.GHash.ghash_incremental0
h_LE
y_orig
(FStar.Seq.Base.slice
#Vale.X64.Decls.quad32
(Vale.X64.Decls.s128
(va_get_mem_heaplet
6
va_s
)
in0_b)
0
((count -
1)
`op_Multiply`
6)))
(va_QBind va_range1
"***** PRECONDITION NOT MET AT line 1123 column 8 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_qIf va_mods
(Cmp_gt
(va_op_cmp_reg64
rRdx
)
(va_const_cmp
0)
)
(qblock va_mods
(fun
(va_s:
va_state
)
->
va_QBind
va_range1
"***** PRECONDITION NOT MET AT line 1125 column 27 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(
va_quick_Loop6x_save_output
count
out_b
)
(
fun
(
va_s:
va_state
)
_
->
va_qAssertSquash
va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 1126 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(
count -
1 >=
0 /\
(
fun
a_1906
(
s_1907:
(
FStar.Seq.Base.seq
a_1906
)
)
(
i_1908:
Prims.nat
)
(
j_1909:
Prims.nat
)
->
let
j_1869:Prims.nat
=
j_1909
in
Prims.b2t
(
Prims.op_AmpAmp
(
Prims.op_LessThanOrEqual
i_1908
j_1869
)
(
Prims.op_LessThanOrEqual
j_1869
(
FStar.Seq.Base.length
#a_1906
s_1907
)
)
)
)
Vale.X64.Decls.quad32
(
Vale.X64.Decls.s128
(
va_get_mem_heaplet
6
va_s
)
out_b
)
0
(
(
count -
1
)
`op_Multiply`
6
)
/\
count -
1 >=
0 /\
(
fun
a_1906
(
s_1907:
(
FStar.Seq.Base.seq
a_1906
)
)
(
i_1908:
Prims.nat
)
(
j_1909:
Prims.nat
)
->
let
j_1869:Prims.nat
=
j_1909
in
Prims.b2t
(
Prims.op_AmpAmp
(
Prims.op_LessThanOrEqual
i_1908
j_1869
)
(
Prims.op_LessThanOrEqual
j_1869
(
FStar.Seq.Base.length
#a_1906
s_1907
)
)
)
)
Vale.X64.Decls.quad32
(
Vale.X64.Decls.s128
mem_snap
out_b
)
0
(
(
count -
1
)
`op_Multiply`
6
)
)
(
fun
_
->
va_qAssert
va_range1
"***** PRECONDITION NOT MET AT line 1126 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(
FStar.Seq.Base.equal
#Vale.X64.Decls.quad32
(
FStar.Seq.Base.slice
#Vale.X64.Decls.quad32
(
Vale.X64.Decls.s128
(
va_get_mem_heaplet
6
va_s
)
out_b
)
0
(
(
count -
1
)
`op_Multiply`
6
)
)
(
FStar.Seq.Base.slice
#Vale.X64.Decls.quad32
(
Vale.X64.Decls.s128
mem_snap
out_b
)
0
(
(
count -
1
)
`op_Multiply`
6
)
)
)
(
va_QBind
va_range1
"***** PRECONDITION NOT MET AT line 1129 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(
va_quick_Load128_buffer
(
va_op_heaplet_mem_heaplet
3
)
(
va_op_xmm_xmm
7
)
(
va_op_reg_opr64_reg64
rRbp
)
32
Secret
scratch_b
2
)
(
fun
(
va_s:
va_state
)
_
->
let
plain:(
FStar.Seq.Base.seq
Vale.X64.Decls.quad32
)
=
Vale.X64.Decls.s128
(
va_get_mem_heaplet
6
va_old_s
)
in_b
in
let
cipher:(
FStar.Seq.Base.seq
Vale.X64.Decls.quad32
)
=
Vale.X64.Decls.s128
(
va_get_mem_heaplet
6
va_s
)
out_b
in
let
bound:(
va_int_at_least
0
)
=
count
`op_Multiply`
6
in
va_qAssertSquash
va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 1134 column 44 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(
bound >=
0 /\
bound <=
4294967295
)
(
fun
_
->
let
va_arg88:Vale.Def.Types_s.quad32
=
ctr_BE_orig
in
let
va_arg87:(
FStar.Seq.Base.seq
Vale.Def.Types_s.nat32
)
=
key_words
in
let
va_arg86:(
FStar.Seq.Base.seq
Vale.Def.Types_s.quad32
)
=
cipher
in
let
va_arg85:(
FStar.Seq.Base.seq
Vale.Def.Types_s.quad32
)
=
Vale.X64.Decls.buffer128_as_seq
(
va_get_mem_heaplet
6
va_old_s
)
out_b
in
let
va_arg84:(
FStar.Seq.Base.seq
Vale.Def.Types_s.quad32
)
=
plain_quads
in
let
va_arg83:(
FStar.Seq.Base.seq
Vale.Def.Types_s.quad32
)
=
plain_quads
in
let
va_arg82:Vale.Def.Types_s.nat32
=
bound
in
let
va_arg81:Vale.AES.AES_common_s.algorithm
=
alg
in
va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 1134 column 44 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(
fun
(
_:
unit
)
->
Vale.AES.GCTR.gctr_partial_opaque_ignores_postfix
va_arg81
va_arg82
va_arg83
va_arg84
va_arg85
va_arg86
va_arg87
va_arg88
)
(
let
va_arg80:Vale.Def.Types_s.quad32
=
ctr_BE_orig
in
let
va_arg79:(
FStar.Seq.Base.seq
Vale.Def.Types_s.nat32
)
=
key_words
in
let
va_arg78:(
FStar.Seq.Base.seq
Vale.Def.Types_s.quad32
)
=
cipher
in
let
va_arg77:(
FStar.Seq.Base.seq
Vale.Def.Types_s.quad32
)
=
plain_quads
in
let
va_arg76:Prims.nat
=
bound
in
let
va_arg75:Vale.AES.AES_common_s.algorithm
=
alg
in
va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 1137 column 29 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(
fun
(
_:
unit
)
->
Vale.AES.GCTR.gctr_partial_extend6
va_arg75
va_arg76
va_arg77
va_arg78
va_arg79
va_arg80
)
(
let
va_arg74:Vale.Math.Poly2_s.poly
=
Vale.Math.Poly2.Bits_s.of_quad32
(
va_get_xmm
4
va_s
)
in
let
va_arg73:Vale.Math.Poly2_s.poly
=
Vale.Math.Poly2.Bits_s.of_quad32
(
Vale.X64.Decls.buffer128_read
scratch_b
1
(
va_get_mem_heaplet
3
va_s
)
)
in
let
va_arg72:Vale.Math.Poly2_s.poly
=
Vale.Math.Poly2.Bits_s.of_quad32
(
va_get_xmm
8
va_s
)
in
va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 1138 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(
fun
(
_:
unit
)
->
Vale.AES.GHash.lemma_add_manip
va_arg72
va_arg73
va_arg74
)
(
va_qAssert
va_range1
"***** PRECONDITION NOT MET AT line 1139 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(
y_new ==
Vale.Def.Types_s.reverse_bytes_quad32
(
Vale.Math.Poly2.Bits_s.to_quad32
(
Vale.Math.Poly2.Bits_s.of_quad32
(
Vale.Def.Types_s.reverse_bytes_quad32
(
Vale.AES.GHash.ghash_incremental
h_LE
y_prev
data
)
)
)
)
)
(
va_QEmpty
(
()
)
)
)
)
)
)
)
)
)
)
))
(qblock va_mods
(fun
(va_s:
va_state
)
->
va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 1143 column 33 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(
va_quick_Mem128_lemma
(
va_op_heaplet_mem_heaplet
3
)
(
va_op_reg64_reg64
rRbp
)
16
Secret
scratch_b
1
)
(
va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 1143 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(
va_quick_VPolyAdd
(
va_op_xmm_xmm
8
)
(
va_op_xmm_xmm
8
)
(
va_opr_code_Mem128
(
va_op_heaplet_mem_heaplet
3
)
(
va_op_reg64_reg64
rRbp
)
16
Secret
)
)
(
va_QBind
va_range1
"***** PRECONDITION NOT MET AT line 1144 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(
va_quick_VPolyAdd
(
va_op_xmm_xmm
8
)
(
va_op_xmm_xmm
8
)
(
va_op_opr128_xmm
4
)
)
(
fun
(
va_s:
va_state
)
_
->
va_qAssert
va_range1
"***** PRECONDITION NOT MET AT line 1145 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(
Vale.Math.Poly2.Bits_s.of_quad32
(
va_get_xmm
8
va_s
)
==
Vale.Math.Poly2.Bits_s.of_quad32
(
Vale.Def.Types_s.reverse_bytes_quad32
(
Vale.AES.GHash.ghash_incremental
h_LE
y_prev
data
)
)
)
(
va_qAssert
va_range1
"***** PRECONDITION NOT MET AT line 1146 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(
Vale.Math.Poly2.Bits_s.to_quad32
(
Vale.Math.Poly2.Bits_s.of_quad32
(
va_get_xmm
8
va_s
)
)
==
Vale.Math.Poly2.Bits_s.to_quad32
(
Vale.Math.Poly2.Bits_s.of_quad32
(
Vale.Def.Types_s.reverse_bytes_quad32
(
Vale.AES.GHash.ghash_incremental
h_LE
y_prev
data
)
)
)
)
(
va_qAssert
va_range1
"***** PRECONDITION NOT MET AT line 1147 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(
va_get_xmm
8
va_s
==
Vale.Def.Types_s.reverse_bytes_quad32
(
Vale.AES.GHash.ghash_incremental
h_LE
y_prev
data
)
)
(
va_QEmpty
(
()
)
)
)
)
)
)
)
))
)
(fun
(va_s:
va_state
)
va_g
->
va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 1149 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun
(_:
unit
)
->
Vale.AES.GCTR.gctr_registers_reveal
()
)
(va_QEmpty
((y_new
))
))))))))
))))))))))) | false |
EtM.AE.fst | EtM.AE.decrypt | val decrypt (k: key) (c: cipher)
: ST (option Plain.plain)
(requires (fun h0 -> invariant h0 k))
(ensures
(fun h0 res h1 ->
modifies_none h0 h1 /\ invariant h1 k /\
(b2t Ideal.uf_cma /\ Some? res ==> Seq.mem (Some?.v res, c) (get_log h0 k)))) | val decrypt (k: key) (c: cipher)
: ST (option Plain.plain)
(requires (fun h0 -> invariant h0 k))
(ensures
(fun h0 res h1 ->
modifies_none h0 h1 /\ invariant h1 k /\
(b2t Ideal.uf_cma /\ Some? res ==> Seq.mem (Some?.v res, c) (get_log h0 k)))) | let decrypt (k:key) (c:cipher)
: ST (option Plain.plain)
(requires (fun h0 -> invariant h0 k))
(ensures (fun h0 res h1 ->
modifies_none h0 h1 /\
invariant h1 k /\
(b2t Ideal.uf_cma /\ Some? res ==>
Seq.mem (Some?.v res, c) (get_log h0 k)))) =
let c, tag = c in
let h0 = FStar.HyperStack.ST.get () in
if MAC.verify k.km c tag
then begin
if Ideal.uf_cma then mac_only_cpa_ciphers_mem (get_mac_log h0 k) (get_cpa_log h0 k) (c, tag);
let p = CPA.decrypt k.ke c in
if Ideal.uf_cma then
(let h = FStar.HyperStack.ST.get() in
invert_invariant h k (c,tag) p);
Some p
end
else None | {
"file_name": "examples/crypto/EtM.AE.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 11,
"end_line": 319,
"start_col": 0,
"start_line": 300
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module EtM.AE
open FStar.Seq
open FStar.Monotonic.Seq
open FStar.HyperStack
open FStar.HyperStack.ST
module MAC = EtM.MAC
open Platform.Bytes
open CoreCrypto
module CPA = EtM.CPA
module MAC = EtM.MAC
module Ideal = EtM.Ideal
module Plain = EtM.Plain
(*** Basic types ***)
type rid = erid
/// An AE cipher includes a mac tag
type cipher = (CPA.cipher * MAC.tag)
/// An AE log pairs plain texts with MAC'd ciphers
let log_entry = Plain.plain * cipher
type log_t (r:rid) = m_rref r (seq log_entry) grows
/// An AE key pairs an encryption key, ke, with a MAC'ing key, km,
/// with an invariant ensuring that their memory footprints of their
/// ideal state are disjoint.
///
/// Aside from this, we have an AE log, which is a view of the two
/// other logs.
noeq type key =
| Key: #region:rid
-> ke:CPA.key { extends (CPA.Key?.region ke) region }
-> km:MAC.key { extends (MAC.Key?.region km) region /\
disjoint( CPA.Key?.region ke) (MAC.Key?.region km) }
-> log:log_t region
-> key
(** Accessors for the three logs **)
/// ae log
let get_log (h:mem) (k:key) =
sel h k.log
/// mac log
let get_mac_log (h:mem) (k:key) =
sel h (MAC.Key?.log k.km)
/// cpa log
let get_cpa_log (h:mem) (k:key) =
sel h (CPA.Key?.log k.ke)
(*** Main invariant on the ideal state ***)
(** There are three components to this invariant
1. The CPA invariant (pairwise distinctness of IVs, notably)
2. mac_only_cpa_ciphers:
The MAC log and CPA logs are related, in that the MAC log only
contains entries for valid ciphers recorded the CPA log
3. mac_and_cpa_refine_ae:
The AE log is a combined view of the MAC and CPA logs Each of
its entries corresponds is combination of a single entry in the
MAC log and another in the CPA log
**)
let mac_cpa_related (mac:EtM.MAC.log_entry) (cpa:EtM.CPA.log_entry) =
CPA.Entry?.c cpa == fst mac
/// See the comment above, for part 2 of the invariant
/// -- As in EtM.CPA, we state the invariant recursively
/// matching entries up pointwise
let rec mac_only_cpa_ciphers (macs:Seq.seq EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length macs)) =
Seq.length macs == Seq.length cpas /\
(if Seq.length macs > 0 then
let macs, mac = Seq.un_snoc macs in
let cpas, cpa = Seq.un_snoc cpas in
mac_cpa_related mac cpa /\
mac_only_cpa_ciphers macs cpas
else True)
/// A lemma to intro/elim the recursive predicate above
let mac_only_cpa_ciphers_snoc (macs:Seq.seq EtM.MAC.log_entry) (mac:EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry) (cpa:EtM.CPA.log_entry)
: Lemma (mac_only_cpa_ciphers (snoc macs mac) (snoc cpas cpa) <==>
(mac_only_cpa_ciphers macs cpas /\ mac_cpa_related mac cpa))
= un_snoc_snoc macs mac;
un_snoc_snoc cpas cpa
/// A lemma that shows that if an cipher is MAC'd
/// then a corresponding entry must exists in the CPA log
let rec mac_only_cpa_ciphers_mem (macs:Seq.seq EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry)
(c:cipher)
: Lemma (requires (mac_only_cpa_ciphers macs cpas /\
Seq.mem c macs))
(ensures (exists p. Seq.mem (CPA.Entry p (fst c)) cpas))
(decreases (Seq.length macs))
= if Seq.length macs = 0 then
()
else let macs, mac = un_snoc macs in
let cpas, cpa = un_snoc cpas in
Seq.lemma_mem_snoc macs mac;
Seq.lemma_mem_snoc cpas cpa;
if mac = c then ()
else mac_only_cpa_ciphers_mem macs cpas c
/// See part 3 of the invariant:
/// -- An AE entry is related to a MAC and CPA entry
/// if its plain text + cipher appears in the CPA entry
/// and its cipher+tag appear in the MAC table
let mac_and_cpa_refine_ae_entry (ae:log_entry)
(mac:EtM.MAC.log_entry)
(cpa:EtM.CPA.log_entry) =
let p, c = ae in
mac == c /\
CPA.Entry p (fst c) == cpa
/// See part 3 of the invariant:
/// -- A pointwise lifting the relation between the entries in the three logs
let rec mac_and_cpa_refine_ae (ae_entries:Seq.seq log_entry)
(mac_entries:Seq.seq EtM.MAC.log_entry)
(cpa_entries:Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length ae_entries)) =
Seq.length ae_entries == Seq.length mac_entries /\
Seq.length mac_entries == Seq.length cpa_entries /\
(if Seq.length ae_entries <> 0
then let ae_prefix, ae_last = Seq.un_snoc ae_entries in
let mac_prefix, mac_last = Seq.un_snoc mac_entries in
let cpa_prefix, cpa_last = Seq.un_snoc cpa_entries in
mac_and_cpa_refine_ae_entry ae_last mac_last cpa_last /\
mac_and_cpa_refine_ae ae_prefix mac_prefix cpa_prefix
else True)
/// A lemma to intro/elim the recursive predicate above
let mac_and_cpa_refine_ae_snoc (ae_entries:Seq.seq log_entry)
(mac_entries:Seq.seq EtM.MAC.log_entry)
(cpa_entries:Seq.seq EtM.CPA.log_entry)
(ae:log_entry)
(mac:EtM.MAC.log_entry)
(cpa:EtM.CPA.log_entry)
: Lemma (mac_and_cpa_refine_ae (snoc ae_entries ae)
(snoc mac_entries mac)
(snoc cpa_entries cpa) <==>
(mac_and_cpa_refine_ae ae_entries mac_entries cpa_entries /\
mac_and_cpa_refine_ae_entry ae mac cpa))
= Seq.un_snoc_snoc ae_entries ae;
Seq.un_snoc_snoc mac_entries mac;
Seq.un_snoc_snoc cpa_entries cpa
/// The main invariant:
/// -- A conjunction of the 3 components already mentioned
/// + some technical invariants about logs being allocated
let invariant (h:mem) (k:key) =
let log = get_log h k in
let mac_log = get_mac_log h k in
let cpa_log = get_cpa_log h k in
Map.contains (get_hmap h) k.region /\
Map.contains (get_hmap h) (MAC.Key?.region k.km) /\
Map.contains (get_hmap h) (CPA.Key?.region k.ke) /\
EtM.CPA.invariant (Key?.ke k) h /\
mac_only_cpa_ciphers (get_mac_log h k) (get_cpa_log h k) /\
mac_and_cpa_refine_ae (get_log h k) (get_mac_log h k) (get_cpa_log h k)
(*** The main AE lemma relying on the invariant ***)
(** For logs that respect the main invariant:
if (c, t) is a valid MAC
and (p, c) is a valid CPA
then (p, (c, t)) must be a in the AE log
The pairwise distinctness of ciphers in the CPA log
plays a crucial role.
For instance, using it, and knowing that (c, t) is a valid MAC,
we can conclude that their must be exactly one entry
in the CPA table containing c. **)
let rec invert_invariant_aux (c:cipher) (p:Plain.plain)
(macs:Seq.seq MAC.log_entry)
(cpas:Seq.seq CPA.log_entry)
(aes :Seq.seq log_entry)
: Lemma (requires (mac_only_cpa_ciphers macs cpas /\
mac_and_cpa_refine_ae aes macs cpas /\
CPA.pairwise_distinct_ivs cpas /\
Seq.mem c macs /\
Seq.mem (CPA.Entry p (fst c)) cpas))
(ensures (Seq.mem (p, c) aes))
(decreases (Seq.length macs))
= assert (Seq.length macs == Seq.length aes);
if Seq.length macs = 0 then ()
else let macs, mac = un_snoc macs in
let cpas, cpa = un_snoc cpas in
let aes, ae = un_snoc aes in
Seq.lemma_mem_snoc aes ae;
Seq.lemma_mem_snoc macs mac;
Seq.lemma_mem_snoc cpas cpa;
if mac = c then begin
assert (CPA.Entry?.c cpa == fst c);
CPA.invert_pairwise cpas cpa (fst c);
assert (not (Seq.mem (CPA.Entry p (fst c)) cpas));
assert (CPA.Entry?.plain cpa == p);
assert (ae = (p, c))
end
else if fst mac = fst c then begin
assert (CPA.Entry?.c cpa == fst c);
mac_only_cpa_ciphers_mem macs cpas c;
assert (exists q1. Seq.mem (CPA.Entry q1 (fst c)) cpas);
CPA.invert_pairwise cpas cpa (fst c)
end
else begin
assert (mac_and_cpa_refine_ae aes macs cpas);
mac_only_cpa_ciphers_snoc macs mac cpas cpa;
CPA.pairwise_snoc cpas cpa;
invert_invariant_aux c p macs cpas aes
end
/// Lifting the lemma above to work on the current state, h
let invert_invariant (h:mem) (k:key) (c:cipher) (p:Plain.plain)
: Lemma (requires (invariant h k /\
Seq.mem c (get_mac_log h k) /\
Seq.mem (CPA.Entry p (fst c)) (get_cpa_log h k)))
(ensures (Seq.mem (p, c) (get_log h k)))
= let macs = get_mac_log h k in
let cpas = get_cpa_log h k in
let aes = get_log h k in
invert_invariant_aux c p macs cpas aes
(*** Main interface of AE
keygen, encrypt, decrypt ***)
/// keygen: create a fresh key in the caller's region
/// its ae log is initially empty
let keygen (parent:rid)
: ST key
(requires (fun _ -> HyperStack.ST.witnessed (region_contains_pred parent)))
(ensures (fun h0 k h1 ->
modifies Set.empty h0 h1 /\
extends k.region parent /\
fresh_region k.region h0 h1 /\
Map.contains (get_hmap h1) k.region /\
contains h1 k.log /\
sel h1 k.log == Seq.empty /\
invariant h1 k)) =
let region = new_region parent in
let ke = CPA.keygen region in
let ka = MAC.keygen region in
let log = alloc_mref_seq region Seq.empty in
Key #region ke ka log
/// encrypt:
/// We return a cipher, preserve the invariant,
/// and extend the log by exactly one entry
#set-options "--max_fuel 1 --max_ifuel 1 --initial_fuel 1 --initial_ifuel 1 --z3rlimit 30"
let encrypt (k:key) (plain:Plain.plain)
: ST cipher
(requires (fun h0 -> invariant h0 k))
(ensures (fun h0 c h1 ->
(let log0 = get_log h0 k in
let log1 = get_log h1 k in
modifies_transitively (Set.singleton k.region) h0 h1
/\ invariant h1 k
/\ log1 == snoc log0 (plain, c)))) =
let h0 = FStar.HyperStack.ST.get () in
let c = CPA.encrypt k.ke plain in
let t = MAC.mac k.km c in
write_at_end k.log (plain, (c, t));
let h1 = FStar.HyperStack.ST.get () in
assert (sel h1 k.log == snoc (sel h0 k.log) (plain, (c, t)));
assert (EtM.CPA.invariant (Key?.ke k) h1);
mac_and_cpa_refine_ae_snoc (get_log h0 k) (get_mac_log h0 k) (get_cpa_log h0 k)
(plain, (c,t)) (c,t) (CPA.Entry plain c);
mac_only_cpa_ciphers_snoc (get_mac_log h0 k) (c,t)
(get_cpa_log h0 k) (CPA.Entry plain c);
(c, t)
/// decrypt:
/// In the ideal case, we prove it functionally correct and secure | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Platform.Bytes.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Seq.fst.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"EtM.Plain.fsti.checked",
"EtM.MAC.fst.checked",
"EtM.Ideal.fsti.checked",
"EtM.CPA.fst.checked",
"CoreCrypto.fst.checked"
],
"interface_file": false,
"source_file": "EtM.AE.fst"
} | [
{
"abbrev": true,
"full_module": "EtM.Plain",
"short_module": "Plain"
},
{
"abbrev": true,
"full_module": "EtM.Ideal",
"short_module": "Ideal"
},
{
"abbrev": true,
"full_module": "EtM.MAC",
"short_module": "MAC"
},
{
"abbrev": true,
"full_module": "EtM.CPA",
"short_module": "CPA"
},
{
"abbrev": false,
"full_module": "CoreCrypto",
"short_module": null
},
{
"abbrev": false,
"full_module": "Platform.Bytes",
"short_module": null
},
{
"abbrev": true,
"full_module": "EtM.MAC",
"short_module": "MAC"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "EtM",
"short_module": null
},
{
"abbrev": false,
"full_module": "EtM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"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": 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": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | k: EtM.AE.key -> c: EtM.AE.cipher
-> FStar.HyperStack.ST.ST (FStar.Pervasives.Native.option EtM.Plain.plain) | FStar.HyperStack.ST.ST | [] | [] | [
"EtM.AE.key",
"EtM.AE.cipher",
"EtM.CPA.cipher",
"EtM.MAC.tag",
"FStar.Pervasives.Native.Some",
"EtM.Plain.plain",
"FStar.Pervasives.Native.option",
"Prims.unit",
"EtM.Ideal.uf_cma",
"EtM.AE.invert_invariant",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Prims.bool",
"EtM.CPA.decrypt",
"EtM.AE.__proj__Key__item__ke",
"EtM.AE.mac_only_cpa_ciphers_mem",
"EtM.AE.get_mac_log",
"EtM.AE.get_cpa_log",
"FStar.Pervasives.Native.None",
"EtM.MAC.verify",
"EtM.AE.__proj__Key__item__km",
"EtM.AE.invariant",
"Prims.l_and",
"FStar.HyperStack.ST.modifies_none",
"Prims.l_imp",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"FStar.Seq.Properties.mem",
"EtM.AE.log_entry",
"FStar.Pervasives.Native.__proj__Some__item__v",
"EtM.AE.get_log"
] | [] | false | true | false | false | false | let decrypt (k: key) (c: cipher)
: ST (option Plain.plain)
(requires (fun h0 -> invariant h0 k))
(ensures
(fun h0 res h1 ->
modifies_none h0 h1 /\ invariant h1 k /\
(b2t Ideal.uf_cma /\ Some? res ==> Seq.mem (Some?.v res, c) (get_log h0 k)))) =
| let c, tag = c in
let h0 = FStar.HyperStack.ST.get () in
if MAC.verify k.km c tag
then
(if Ideal.uf_cma then mac_only_cpa_ciphers_mem (get_mac_log h0 k) (get_cpa_log h0 k) (c, tag);
let p = CPA.decrypt k.ke c in
if Ideal.uf_cma
then
(let h = FStar.HyperStack.ST.get () in
invert_invariant h k (c, tag) p);
Some p)
else None | false |
Steel.PCMFrac.fst | Steel.PCMFrac.composable | val composable (#a: _) : symrel (fractional a) | val composable (#a: _) : symrel (fractional a) | let composable #a : symrel (fractional a) =
fun (f0 f1:fractional a) ->
match f0, f1 with
| None, _
| _, None -> True
| Some (x0, p0), Some (x1, p1) -> x0==x1 /\ (sum_perm p0 p1).v <=. one | {
"file_name": "lib/steel/Steel.PCMFrac.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 74,
"end_line": 12,
"start_col": 0,
"start_line": 7
} | module Steel.PCMFrac
include FStar.PCM
include Steel.FractionalPermission
open FStar.Real | {
"checked_file": "/",
"dependencies": [
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.PCMFrac.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | FStar.PCM.symrel (Steel.PCMFrac.fractional a) | Prims.Tot | [
"total"
] | [] | [
"Steel.PCMFrac.fractional",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"Steel.FractionalPermission.perm",
"Prims.l_True",
"Prims.l_and",
"Prims.eq2",
"Prims.b2t",
"FStar.Real.op_Less_Equals_Dot",
"Steel.FractionalPermission.__proj__MkPerm__item__v",
"Steel.FractionalPermission.sum_perm",
"FStar.Real.one",
"Prims.prop",
"FStar.PCM.symrel"
] | [] | false | false | false | true | false | let composable #a : symrel (fractional a) =
| fun (f0: fractional a) (f1: fractional a) ->
match f0, f1 with
| None, _ | _, None -> True
| Some (x0, p0), Some (x1, p1) -> x0 == x1 /\ (sum_perm p0 p1).v <=. one | false |
EtM.AE.fst | EtM.AE.invert_invariant_aux | val invert_invariant_aux
(c: cipher)
(p: Plain.plain)
(macs: Seq.seq MAC.log_entry)
(cpas: Seq.seq CPA.log_entry)
(aes: Seq.seq log_entry)
: Lemma
(requires
(mac_only_cpa_ciphers macs cpas /\ mac_and_cpa_refine_ae aes macs cpas /\
CPA.pairwise_distinct_ivs cpas /\ Seq.mem c macs /\ Seq.mem (CPA.Entry p (fst c)) cpas))
(ensures (Seq.mem (p, c) aes))
(decreases (Seq.length macs)) | val invert_invariant_aux
(c: cipher)
(p: Plain.plain)
(macs: Seq.seq MAC.log_entry)
(cpas: Seq.seq CPA.log_entry)
(aes: Seq.seq log_entry)
: Lemma
(requires
(mac_only_cpa_ciphers macs cpas /\ mac_and_cpa_refine_ae aes macs cpas /\
CPA.pairwise_distinct_ivs cpas /\ Seq.mem c macs /\ Seq.mem (CPA.Entry p (fst c)) cpas))
(ensures (Seq.mem (p, c) aes))
(decreases (Seq.length macs)) | let rec invert_invariant_aux (c:cipher) (p:Plain.plain)
(macs:Seq.seq MAC.log_entry)
(cpas:Seq.seq CPA.log_entry)
(aes :Seq.seq log_entry)
: Lemma (requires (mac_only_cpa_ciphers macs cpas /\
mac_and_cpa_refine_ae aes macs cpas /\
CPA.pairwise_distinct_ivs cpas /\
Seq.mem c macs /\
Seq.mem (CPA.Entry p (fst c)) cpas))
(ensures (Seq.mem (p, c) aes))
(decreases (Seq.length macs))
= assert (Seq.length macs == Seq.length aes);
if Seq.length macs = 0 then ()
else let macs, mac = un_snoc macs in
let cpas, cpa = un_snoc cpas in
let aes, ae = un_snoc aes in
Seq.lemma_mem_snoc aes ae;
Seq.lemma_mem_snoc macs mac;
Seq.lemma_mem_snoc cpas cpa;
if mac = c then begin
assert (CPA.Entry?.c cpa == fst c);
CPA.invert_pairwise cpas cpa (fst c);
assert (not (Seq.mem (CPA.Entry p (fst c)) cpas));
assert (CPA.Entry?.plain cpa == p);
assert (ae = (p, c))
end
else if fst mac = fst c then begin
assert (CPA.Entry?.c cpa == fst c);
mac_only_cpa_ciphers_mem macs cpas c;
assert (exists q1. Seq.mem (CPA.Entry q1 (fst c)) cpas);
CPA.invert_pairwise cpas cpa (fst c)
end
else begin
assert (mac_and_cpa_refine_ae aes macs cpas);
mac_only_cpa_ciphers_snoc macs mac cpas cpa;
CPA.pairwise_snoc cpas cpa;
invert_invariant_aux c p macs cpas aes
end | {
"file_name": "examples/crypto/EtM.AE.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 14,
"end_line": 236,
"start_col": 0,
"start_line": 199
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module EtM.AE
open FStar.Seq
open FStar.Monotonic.Seq
open FStar.HyperStack
open FStar.HyperStack.ST
module MAC = EtM.MAC
open Platform.Bytes
open CoreCrypto
module CPA = EtM.CPA
module MAC = EtM.MAC
module Ideal = EtM.Ideal
module Plain = EtM.Plain
(*** Basic types ***)
type rid = erid
/// An AE cipher includes a mac tag
type cipher = (CPA.cipher * MAC.tag)
/// An AE log pairs plain texts with MAC'd ciphers
let log_entry = Plain.plain * cipher
type log_t (r:rid) = m_rref r (seq log_entry) grows
/// An AE key pairs an encryption key, ke, with a MAC'ing key, km,
/// with an invariant ensuring that their memory footprints of their
/// ideal state are disjoint.
///
/// Aside from this, we have an AE log, which is a view of the two
/// other logs.
noeq type key =
| Key: #region:rid
-> ke:CPA.key { extends (CPA.Key?.region ke) region }
-> km:MAC.key { extends (MAC.Key?.region km) region /\
disjoint( CPA.Key?.region ke) (MAC.Key?.region km) }
-> log:log_t region
-> key
(** Accessors for the three logs **)
/// ae log
let get_log (h:mem) (k:key) =
sel h k.log
/// mac log
let get_mac_log (h:mem) (k:key) =
sel h (MAC.Key?.log k.km)
/// cpa log
let get_cpa_log (h:mem) (k:key) =
sel h (CPA.Key?.log k.ke)
(*** Main invariant on the ideal state ***)
(** There are three components to this invariant
1. The CPA invariant (pairwise distinctness of IVs, notably)
2. mac_only_cpa_ciphers:
The MAC log and CPA logs are related, in that the MAC log only
contains entries for valid ciphers recorded the CPA log
3. mac_and_cpa_refine_ae:
The AE log is a combined view of the MAC and CPA logs Each of
its entries corresponds is combination of a single entry in the
MAC log and another in the CPA log
**)
let mac_cpa_related (mac:EtM.MAC.log_entry) (cpa:EtM.CPA.log_entry) =
CPA.Entry?.c cpa == fst mac
/// See the comment above, for part 2 of the invariant
/// -- As in EtM.CPA, we state the invariant recursively
/// matching entries up pointwise
let rec mac_only_cpa_ciphers (macs:Seq.seq EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length macs)) =
Seq.length macs == Seq.length cpas /\
(if Seq.length macs > 0 then
let macs, mac = Seq.un_snoc macs in
let cpas, cpa = Seq.un_snoc cpas in
mac_cpa_related mac cpa /\
mac_only_cpa_ciphers macs cpas
else True)
/// A lemma to intro/elim the recursive predicate above
let mac_only_cpa_ciphers_snoc (macs:Seq.seq EtM.MAC.log_entry) (mac:EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry) (cpa:EtM.CPA.log_entry)
: Lemma (mac_only_cpa_ciphers (snoc macs mac) (snoc cpas cpa) <==>
(mac_only_cpa_ciphers macs cpas /\ mac_cpa_related mac cpa))
= un_snoc_snoc macs mac;
un_snoc_snoc cpas cpa
/// A lemma that shows that if an cipher is MAC'd
/// then a corresponding entry must exists in the CPA log
let rec mac_only_cpa_ciphers_mem (macs:Seq.seq EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry)
(c:cipher)
: Lemma (requires (mac_only_cpa_ciphers macs cpas /\
Seq.mem c macs))
(ensures (exists p. Seq.mem (CPA.Entry p (fst c)) cpas))
(decreases (Seq.length macs))
= if Seq.length macs = 0 then
()
else let macs, mac = un_snoc macs in
let cpas, cpa = un_snoc cpas in
Seq.lemma_mem_snoc macs mac;
Seq.lemma_mem_snoc cpas cpa;
if mac = c then ()
else mac_only_cpa_ciphers_mem macs cpas c
/// See part 3 of the invariant:
/// -- An AE entry is related to a MAC and CPA entry
/// if its plain text + cipher appears in the CPA entry
/// and its cipher+tag appear in the MAC table
let mac_and_cpa_refine_ae_entry (ae:log_entry)
(mac:EtM.MAC.log_entry)
(cpa:EtM.CPA.log_entry) =
let p, c = ae in
mac == c /\
CPA.Entry p (fst c) == cpa
/// See part 3 of the invariant:
/// -- A pointwise lifting the relation between the entries in the three logs
let rec mac_and_cpa_refine_ae (ae_entries:Seq.seq log_entry)
(mac_entries:Seq.seq EtM.MAC.log_entry)
(cpa_entries:Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length ae_entries)) =
Seq.length ae_entries == Seq.length mac_entries /\
Seq.length mac_entries == Seq.length cpa_entries /\
(if Seq.length ae_entries <> 0
then let ae_prefix, ae_last = Seq.un_snoc ae_entries in
let mac_prefix, mac_last = Seq.un_snoc mac_entries in
let cpa_prefix, cpa_last = Seq.un_snoc cpa_entries in
mac_and_cpa_refine_ae_entry ae_last mac_last cpa_last /\
mac_and_cpa_refine_ae ae_prefix mac_prefix cpa_prefix
else True)
/// A lemma to intro/elim the recursive predicate above
let mac_and_cpa_refine_ae_snoc (ae_entries:Seq.seq log_entry)
(mac_entries:Seq.seq EtM.MAC.log_entry)
(cpa_entries:Seq.seq EtM.CPA.log_entry)
(ae:log_entry)
(mac:EtM.MAC.log_entry)
(cpa:EtM.CPA.log_entry)
: Lemma (mac_and_cpa_refine_ae (snoc ae_entries ae)
(snoc mac_entries mac)
(snoc cpa_entries cpa) <==>
(mac_and_cpa_refine_ae ae_entries mac_entries cpa_entries /\
mac_and_cpa_refine_ae_entry ae mac cpa))
= Seq.un_snoc_snoc ae_entries ae;
Seq.un_snoc_snoc mac_entries mac;
Seq.un_snoc_snoc cpa_entries cpa
/// The main invariant:
/// -- A conjunction of the 3 components already mentioned
/// + some technical invariants about logs being allocated
let invariant (h:mem) (k:key) =
let log = get_log h k in
let mac_log = get_mac_log h k in
let cpa_log = get_cpa_log h k in
Map.contains (get_hmap h) k.region /\
Map.contains (get_hmap h) (MAC.Key?.region k.km) /\
Map.contains (get_hmap h) (CPA.Key?.region k.ke) /\
EtM.CPA.invariant (Key?.ke k) h /\
mac_only_cpa_ciphers (get_mac_log h k) (get_cpa_log h k) /\
mac_and_cpa_refine_ae (get_log h k) (get_mac_log h k) (get_cpa_log h k)
(*** The main AE lemma relying on the invariant ***)
(** For logs that respect the main invariant:
if (c, t) is a valid MAC
and (p, c) is a valid CPA
then (p, (c, t)) must be a in the AE log
The pairwise distinctness of ciphers in the CPA log
plays a crucial role.
For instance, using it, and knowing that (c, t) is a valid MAC,
we can conclude that their must be exactly one entry | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Platform.Bytes.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Seq.fst.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"EtM.Plain.fsti.checked",
"EtM.MAC.fst.checked",
"EtM.Ideal.fsti.checked",
"EtM.CPA.fst.checked",
"CoreCrypto.fst.checked"
],
"interface_file": false,
"source_file": "EtM.AE.fst"
} | [
{
"abbrev": true,
"full_module": "EtM.Plain",
"short_module": "Plain"
},
{
"abbrev": true,
"full_module": "EtM.Ideal",
"short_module": "Ideal"
},
{
"abbrev": true,
"full_module": "EtM.MAC",
"short_module": "MAC"
},
{
"abbrev": true,
"full_module": "EtM.CPA",
"short_module": "CPA"
},
{
"abbrev": false,
"full_module": "CoreCrypto",
"short_module": null
},
{
"abbrev": false,
"full_module": "Platform.Bytes",
"short_module": null
},
{
"abbrev": true,
"full_module": "EtM.MAC",
"short_module": "MAC"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "EtM",
"short_module": null
},
{
"abbrev": false,
"full_module": "EtM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
c: EtM.AE.cipher ->
p: EtM.Plain.plain ->
macs: FStar.Seq.Base.seq EtM.MAC.log_entry ->
cpas: FStar.Seq.Base.seq EtM.CPA.log_entry ->
aes: FStar.Seq.Base.seq EtM.AE.log_entry
-> FStar.Pervasives.Lemma
(requires
EtM.AE.mac_only_cpa_ciphers macs cpas /\ EtM.AE.mac_and_cpa_refine_ae aes macs cpas /\
EtM.CPA.pairwise_distinct_ivs cpas /\ FStar.Seq.Properties.mem c macs /\
FStar.Seq.Properties.mem (EtM.CPA.Entry p (FStar.Pervasives.Native.fst c)) cpas)
(ensures FStar.Seq.Properties.mem (p, c) aes)
(decreases FStar.Seq.Base.length macs) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"EtM.AE.cipher",
"EtM.Plain.plain",
"FStar.Seq.Base.seq",
"EtM.MAC.log_entry",
"EtM.CPA.log_entry",
"EtM.AE.log_entry",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.bool",
"FStar.Pervasives.Native.tuple2",
"EtM.CPA.cipher",
"EtM.MAC.tag",
"Prims._assert",
"Prims.b2t",
"FStar.Pervasives.Native.Mktuple2",
"Prims.unit",
"Prims.eq2",
"EtM.CPA.__proj__Entry__item__plain",
"Prims.op_Negation",
"FStar.Seq.Properties.mem",
"EtM.CPA.Entry",
"FStar.Pervasives.Native.fst",
"EtM.CPA.invert_pairwise",
"EtM.CPA.__proj__Entry__item__c",
"EtM.MAC.msg",
"Prims.l_Exists",
"EtM.AE.mac_only_cpa_ciphers_mem",
"EtM.AE.invert_invariant_aux",
"EtM.CPA.pairwise_snoc",
"EtM.AE.mac_only_cpa_ciphers_snoc",
"EtM.AE.mac_and_cpa_refine_ae",
"FStar.Seq.Properties.lemma_mem_snoc",
"FStar.Monotonic.Seq.un_snoc",
"Prims.nat",
"Prims.l_and",
"EtM.AE.mac_only_cpa_ciphers",
"EtM.CPA.pairwise_distinct_ivs",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec invert_invariant_aux
(c: cipher)
(p: Plain.plain)
(macs: Seq.seq MAC.log_entry)
(cpas: Seq.seq CPA.log_entry)
(aes: Seq.seq log_entry)
: Lemma
(requires
(mac_only_cpa_ciphers macs cpas /\ mac_and_cpa_refine_ae aes macs cpas /\
CPA.pairwise_distinct_ivs cpas /\ Seq.mem c macs /\ Seq.mem (CPA.Entry p (fst c)) cpas))
(ensures (Seq.mem (p, c) aes))
(decreases (Seq.length macs)) =
| assert (Seq.length macs == Seq.length aes);
if Seq.length macs = 0
then ()
else
let macs, mac = un_snoc macs in
let cpas, cpa = un_snoc cpas in
let aes, ae = un_snoc aes in
Seq.lemma_mem_snoc aes ae;
Seq.lemma_mem_snoc macs mac;
Seq.lemma_mem_snoc cpas cpa;
if mac = c
then
(assert (CPA.Entry?.c cpa == fst c);
CPA.invert_pairwise cpas cpa (fst c);
assert (not (Seq.mem (CPA.Entry p (fst c)) cpas));
assert (CPA.Entry?.plain cpa == p);
assert (ae = (p, c)))
else
if fst mac = fst c
then
(assert (CPA.Entry?.c cpa == fst c);
mac_only_cpa_ciphers_mem macs cpas c;
assert (exists q1. Seq.mem (CPA.Entry q1 (fst c)) cpas);
CPA.invert_pairwise cpas cpa (fst c))
else
(assert (mac_and_cpa_refine_ae aes macs cpas);
mac_only_cpa_ciphers_snoc macs mac cpas cpa;
CPA.pairwise_snoc cpas cpa;
invert_invariant_aux c p macs cpas aes) | false |
Steel.PCMFrac.fst | Steel.PCMFrac.mk_frame_preserving_upd | val mk_frame_preserving_upd (#a: Type) (v0: Ghost.erased a) (v1: a)
: Tot (frame_preserving_upd pcm_frac (Some (Ghost.reveal v0, full_perm)) (Some (v1, full_perm))) | val mk_frame_preserving_upd (#a: Type) (v0: Ghost.erased a) (v1: a)
: Tot (frame_preserving_upd pcm_frac (Some (Ghost.reveal v0, full_perm)) (Some (v1, full_perm))) | let mk_frame_preserving_upd
(#a: Type)
(v0: Ghost.erased a)
(v1: a)
: Tot (frame_preserving_upd pcm_frac (Some (Ghost.reveal v0, full_perm)) (Some (v1, full_perm)))
= fun _ -> Some (v1, full_perm) | {
"file_name": "lib/steel/Steel.PCMFrac.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 31,
"end_line": 37,
"start_col": 0,
"start_line": 32
} | module Steel.PCMFrac
include FStar.PCM
include Steel.FractionalPermission
open FStar.Real
let fractional (a:Type u#a) = option (a & perm)
let composable #a : symrel (fractional a) =
fun (f0 f1:fractional a) ->
match f0, f1 with
| None, _
| _, None -> True
| Some (x0, p0), Some (x1, p1) -> x0==x1 /\ (sum_perm p0 p1).v <=. one
let compose #a (f0:fractional a) (f1:fractional a{composable f0 f1}) : fractional a =
match f0, f1 with
| None, f
| f, None -> f
| Some (x0, p0), Some (_, p1) -> Some (x0, sum_perm p0 p1)
let pcm_frac #a : pcm (fractional a) = {
p = {
composable = composable;
op = compose;
one = None
};
comm = (fun _ _ -> ());
assoc = (fun _ _ _ -> ());
assoc_r = (fun _ _ _ -> ());
is_unit = (fun _ -> ());
refine = (fun _ -> True)
} | {
"checked_file": "/",
"dependencies": [
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.PCMFrac.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | v0: FStar.Ghost.erased a -> v1: a
-> FStar.PCM.frame_preserving_upd Steel.PCMFrac.pcm_frac
(FStar.Pervasives.Native.Some (FStar.Ghost.reveal v0, Steel.FractionalPermission.full_perm))
(FStar.Pervasives.Native.Some (v1, Steel.FractionalPermission.full_perm)) | Prims.Tot | [
"total"
] | [] | [
"FStar.Ghost.erased",
"Steel.PCMFrac.fractional",
"Prims.l_and",
"FStar.PCM.__proj__Mkpcm__item__refine",
"Steel.PCMFrac.pcm_frac",
"FStar.PCM.compatible",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"Steel.FractionalPermission.perm",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Ghost.reveal",
"Steel.FractionalPermission.full_perm",
"Prims.l_Forall",
"FStar.PCM.composable",
"Prims.l_imp",
"Prims.eq2",
"FStar.PCM.op",
"FStar.PCM.frame_preserving_upd"
] | [] | false | false | false | false | false | let mk_frame_preserving_upd (#a: Type) (v0: Ghost.erased a) (v1: a)
: Tot (frame_preserving_upd pcm_frac (Some (Ghost.reveal v0, full_perm)) (Some (v1, full_perm))) =
| fun _ -> Some (v1, full_perm) | false |
Steel.PCMFrac.fst | Steel.PCMFrac.compose | val compose (#a: _) (f0: fractional a) (f1: fractional a {composable f0 f1}) : fractional a | val compose (#a: _) (f0: fractional a) (f1: fractional a {composable f0 f1}) : fractional a | let compose #a (f0:fractional a) (f1:fractional a{composable f0 f1}) : fractional a =
match f0, f1 with
| None, f
| f, None -> f
| Some (x0, p0), Some (_, p1) -> Some (x0, sum_perm p0 p1) | {
"file_name": "lib/steel/Steel.PCMFrac.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 60,
"end_line": 17,
"start_col": 0,
"start_line": 13
} | module Steel.PCMFrac
include FStar.PCM
include Steel.FractionalPermission
open FStar.Real
let fractional (a:Type u#a) = option (a & perm)
let composable #a : symrel (fractional a) =
fun (f0 f1:fractional a) ->
match f0, f1 with
| None, _
| _, None -> True | {
"checked_file": "/",
"dependencies": [
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.PCMFrac.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | f0: Steel.PCMFrac.fractional a -> f1: Steel.PCMFrac.fractional a {Steel.PCMFrac.composable f0 f1}
-> Steel.PCMFrac.fractional a | Prims.Tot | [
"total"
] | [] | [
"Steel.PCMFrac.fractional",
"Steel.PCMFrac.composable",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"Steel.FractionalPermission.perm",
"FStar.Pervasives.Native.Some",
"Steel.FractionalPermission.sum_perm"
] | [] | false | false | false | false | false | let compose #a (f0: fractional a) (f1: fractional a {composable f0 f1}) : fractional a =
| match f0, f1 with
| None, f | f, None -> f
| Some (x0, p0), Some (_, p1) -> Some (x0, sum_perm p0 p1) | false |
EtM.AE.fst | EtM.AE.encrypt | val encrypt (k: key) (plain: Plain.plain)
: ST cipher
(requires (fun h0 -> invariant h0 k))
(ensures
(fun h0 c h1 ->
(let log0 = get_log h0 k in
let log1 = get_log h1 k in
modifies_transitively (Set.singleton k.region) h0 h1 /\ invariant h1 k /\
log1 == snoc log0 (plain, c)))) | val encrypt (k: key) (plain: Plain.plain)
: ST cipher
(requires (fun h0 -> invariant h0 k))
(ensures
(fun h0 c h1 ->
(let log0 = get_log h0 k in
let log1 = get_log h1 k in
modifies_transitively (Set.singleton k.region) h0 h1 /\ invariant h1 k /\
log1 == snoc log0 (plain, c)))) | let encrypt (k:key) (plain:Plain.plain)
: ST cipher
(requires (fun h0 -> invariant h0 k))
(ensures (fun h0 c h1 ->
(let log0 = get_log h0 k in
let log1 = get_log h1 k in
modifies_transitively (Set.singleton k.region) h0 h1
/\ invariant h1 k
/\ log1 == snoc log0 (plain, c)))) =
let h0 = FStar.HyperStack.ST.get () in
let c = CPA.encrypt k.ke plain in
let t = MAC.mac k.km c in
write_at_end k.log (plain, (c, t));
let h1 = FStar.HyperStack.ST.get () in
assert (sel h1 k.log == snoc (sel h0 k.log) (plain, (c, t)));
assert (EtM.CPA.invariant (Key?.ke k) h1);
mac_and_cpa_refine_ae_snoc (get_log h0 k) (get_mac_log h0 k) (get_cpa_log h0 k)
(plain, (c,t)) (c,t) (CPA.Entry plain c);
mac_only_cpa_ciphers_snoc (get_mac_log h0 k) (c,t)
(get_cpa_log h0 k) (CPA.Entry plain c);
(c, t) | {
"file_name": "examples/crypto/EtM.AE.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 8,
"end_line": 295,
"start_col": 0,
"start_line": 275
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module EtM.AE
open FStar.Seq
open FStar.Monotonic.Seq
open FStar.HyperStack
open FStar.HyperStack.ST
module MAC = EtM.MAC
open Platform.Bytes
open CoreCrypto
module CPA = EtM.CPA
module MAC = EtM.MAC
module Ideal = EtM.Ideal
module Plain = EtM.Plain
(*** Basic types ***)
type rid = erid
/// An AE cipher includes a mac tag
type cipher = (CPA.cipher * MAC.tag)
/// An AE log pairs plain texts with MAC'd ciphers
let log_entry = Plain.plain * cipher
type log_t (r:rid) = m_rref r (seq log_entry) grows
/// An AE key pairs an encryption key, ke, with a MAC'ing key, km,
/// with an invariant ensuring that their memory footprints of their
/// ideal state are disjoint.
///
/// Aside from this, we have an AE log, which is a view of the two
/// other logs.
noeq type key =
| Key: #region:rid
-> ke:CPA.key { extends (CPA.Key?.region ke) region }
-> km:MAC.key { extends (MAC.Key?.region km) region /\
disjoint( CPA.Key?.region ke) (MAC.Key?.region km) }
-> log:log_t region
-> key
(** Accessors for the three logs **)
/// ae log
let get_log (h:mem) (k:key) =
sel h k.log
/// mac log
let get_mac_log (h:mem) (k:key) =
sel h (MAC.Key?.log k.km)
/// cpa log
let get_cpa_log (h:mem) (k:key) =
sel h (CPA.Key?.log k.ke)
(*** Main invariant on the ideal state ***)
(** There are three components to this invariant
1. The CPA invariant (pairwise distinctness of IVs, notably)
2. mac_only_cpa_ciphers:
The MAC log and CPA logs are related, in that the MAC log only
contains entries for valid ciphers recorded the CPA log
3. mac_and_cpa_refine_ae:
The AE log is a combined view of the MAC and CPA logs Each of
its entries corresponds is combination of a single entry in the
MAC log and another in the CPA log
**)
let mac_cpa_related (mac:EtM.MAC.log_entry) (cpa:EtM.CPA.log_entry) =
CPA.Entry?.c cpa == fst mac
/// See the comment above, for part 2 of the invariant
/// -- As in EtM.CPA, we state the invariant recursively
/// matching entries up pointwise
let rec mac_only_cpa_ciphers (macs:Seq.seq EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length macs)) =
Seq.length macs == Seq.length cpas /\
(if Seq.length macs > 0 then
let macs, mac = Seq.un_snoc macs in
let cpas, cpa = Seq.un_snoc cpas in
mac_cpa_related mac cpa /\
mac_only_cpa_ciphers macs cpas
else True)
/// A lemma to intro/elim the recursive predicate above
let mac_only_cpa_ciphers_snoc (macs:Seq.seq EtM.MAC.log_entry) (mac:EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry) (cpa:EtM.CPA.log_entry)
: Lemma (mac_only_cpa_ciphers (snoc macs mac) (snoc cpas cpa) <==>
(mac_only_cpa_ciphers macs cpas /\ mac_cpa_related mac cpa))
= un_snoc_snoc macs mac;
un_snoc_snoc cpas cpa
/// A lemma that shows that if an cipher is MAC'd
/// then a corresponding entry must exists in the CPA log
let rec mac_only_cpa_ciphers_mem (macs:Seq.seq EtM.MAC.log_entry)
(cpas:Seq.seq EtM.CPA.log_entry)
(c:cipher)
: Lemma (requires (mac_only_cpa_ciphers macs cpas /\
Seq.mem c macs))
(ensures (exists p. Seq.mem (CPA.Entry p (fst c)) cpas))
(decreases (Seq.length macs))
= if Seq.length macs = 0 then
()
else let macs, mac = un_snoc macs in
let cpas, cpa = un_snoc cpas in
Seq.lemma_mem_snoc macs mac;
Seq.lemma_mem_snoc cpas cpa;
if mac = c then ()
else mac_only_cpa_ciphers_mem macs cpas c
/// See part 3 of the invariant:
/// -- An AE entry is related to a MAC and CPA entry
/// if its plain text + cipher appears in the CPA entry
/// and its cipher+tag appear in the MAC table
let mac_and_cpa_refine_ae_entry (ae:log_entry)
(mac:EtM.MAC.log_entry)
(cpa:EtM.CPA.log_entry) =
let p, c = ae in
mac == c /\
CPA.Entry p (fst c) == cpa
/// See part 3 of the invariant:
/// -- A pointwise lifting the relation between the entries in the three logs
let rec mac_and_cpa_refine_ae (ae_entries:Seq.seq log_entry)
(mac_entries:Seq.seq EtM.MAC.log_entry)
(cpa_entries:Seq.seq EtM.CPA.log_entry)
: Tot Type0 (decreases (Seq.length ae_entries)) =
Seq.length ae_entries == Seq.length mac_entries /\
Seq.length mac_entries == Seq.length cpa_entries /\
(if Seq.length ae_entries <> 0
then let ae_prefix, ae_last = Seq.un_snoc ae_entries in
let mac_prefix, mac_last = Seq.un_snoc mac_entries in
let cpa_prefix, cpa_last = Seq.un_snoc cpa_entries in
mac_and_cpa_refine_ae_entry ae_last mac_last cpa_last /\
mac_and_cpa_refine_ae ae_prefix mac_prefix cpa_prefix
else True)
/// A lemma to intro/elim the recursive predicate above
let mac_and_cpa_refine_ae_snoc (ae_entries:Seq.seq log_entry)
(mac_entries:Seq.seq EtM.MAC.log_entry)
(cpa_entries:Seq.seq EtM.CPA.log_entry)
(ae:log_entry)
(mac:EtM.MAC.log_entry)
(cpa:EtM.CPA.log_entry)
: Lemma (mac_and_cpa_refine_ae (snoc ae_entries ae)
(snoc mac_entries mac)
(snoc cpa_entries cpa) <==>
(mac_and_cpa_refine_ae ae_entries mac_entries cpa_entries /\
mac_and_cpa_refine_ae_entry ae mac cpa))
= Seq.un_snoc_snoc ae_entries ae;
Seq.un_snoc_snoc mac_entries mac;
Seq.un_snoc_snoc cpa_entries cpa
/// The main invariant:
/// -- A conjunction of the 3 components already mentioned
/// + some technical invariants about logs being allocated
let invariant (h:mem) (k:key) =
let log = get_log h k in
let mac_log = get_mac_log h k in
let cpa_log = get_cpa_log h k in
Map.contains (get_hmap h) k.region /\
Map.contains (get_hmap h) (MAC.Key?.region k.km) /\
Map.contains (get_hmap h) (CPA.Key?.region k.ke) /\
EtM.CPA.invariant (Key?.ke k) h /\
mac_only_cpa_ciphers (get_mac_log h k) (get_cpa_log h k) /\
mac_and_cpa_refine_ae (get_log h k) (get_mac_log h k) (get_cpa_log h k)
(*** The main AE lemma relying on the invariant ***)
(** For logs that respect the main invariant:
if (c, t) is a valid MAC
and (p, c) is a valid CPA
then (p, (c, t)) must be a in the AE log
The pairwise distinctness of ciphers in the CPA log
plays a crucial role.
For instance, using it, and knowing that (c, t) is a valid MAC,
we can conclude that their must be exactly one entry
in the CPA table containing c. **)
let rec invert_invariant_aux (c:cipher) (p:Plain.plain)
(macs:Seq.seq MAC.log_entry)
(cpas:Seq.seq CPA.log_entry)
(aes :Seq.seq log_entry)
: Lemma (requires (mac_only_cpa_ciphers macs cpas /\
mac_and_cpa_refine_ae aes macs cpas /\
CPA.pairwise_distinct_ivs cpas /\
Seq.mem c macs /\
Seq.mem (CPA.Entry p (fst c)) cpas))
(ensures (Seq.mem (p, c) aes))
(decreases (Seq.length macs))
= assert (Seq.length macs == Seq.length aes);
if Seq.length macs = 0 then ()
else let macs, mac = un_snoc macs in
let cpas, cpa = un_snoc cpas in
let aes, ae = un_snoc aes in
Seq.lemma_mem_snoc aes ae;
Seq.lemma_mem_snoc macs mac;
Seq.lemma_mem_snoc cpas cpa;
if mac = c then begin
assert (CPA.Entry?.c cpa == fst c);
CPA.invert_pairwise cpas cpa (fst c);
assert (not (Seq.mem (CPA.Entry p (fst c)) cpas));
assert (CPA.Entry?.plain cpa == p);
assert (ae = (p, c))
end
else if fst mac = fst c then begin
assert (CPA.Entry?.c cpa == fst c);
mac_only_cpa_ciphers_mem macs cpas c;
assert (exists q1. Seq.mem (CPA.Entry q1 (fst c)) cpas);
CPA.invert_pairwise cpas cpa (fst c)
end
else begin
assert (mac_and_cpa_refine_ae aes macs cpas);
mac_only_cpa_ciphers_snoc macs mac cpas cpa;
CPA.pairwise_snoc cpas cpa;
invert_invariant_aux c p macs cpas aes
end
/// Lifting the lemma above to work on the current state, h
let invert_invariant (h:mem) (k:key) (c:cipher) (p:Plain.plain)
: Lemma (requires (invariant h k /\
Seq.mem c (get_mac_log h k) /\
Seq.mem (CPA.Entry p (fst c)) (get_cpa_log h k)))
(ensures (Seq.mem (p, c) (get_log h k)))
= let macs = get_mac_log h k in
let cpas = get_cpa_log h k in
let aes = get_log h k in
invert_invariant_aux c p macs cpas aes
(*** Main interface of AE
keygen, encrypt, decrypt ***)
/// keygen: create a fresh key in the caller's region
/// its ae log is initially empty
let keygen (parent:rid)
: ST key
(requires (fun _ -> HyperStack.ST.witnessed (region_contains_pred parent)))
(ensures (fun h0 k h1 ->
modifies Set.empty h0 h1 /\
extends k.region parent /\
fresh_region k.region h0 h1 /\
Map.contains (get_hmap h1) k.region /\
contains h1 k.log /\
sel h1 k.log == Seq.empty /\
invariant h1 k)) =
let region = new_region parent in
let ke = CPA.keygen region in
let ka = MAC.keygen region in
let log = alloc_mref_seq region Seq.empty in
Key #region ke ka log
/// encrypt:
/// We return a cipher, preserve the invariant,
/// and extend the log by exactly one entry | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Platform.Bytes.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Seq.fst.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"EtM.Plain.fsti.checked",
"EtM.MAC.fst.checked",
"EtM.Ideal.fsti.checked",
"EtM.CPA.fst.checked",
"CoreCrypto.fst.checked"
],
"interface_file": false,
"source_file": "EtM.AE.fst"
} | [
{
"abbrev": true,
"full_module": "EtM.Plain",
"short_module": "Plain"
},
{
"abbrev": true,
"full_module": "EtM.Ideal",
"short_module": "Ideal"
},
{
"abbrev": true,
"full_module": "EtM.MAC",
"short_module": "MAC"
},
{
"abbrev": true,
"full_module": "EtM.CPA",
"short_module": "CPA"
},
{
"abbrev": false,
"full_module": "CoreCrypto",
"short_module": null
},
{
"abbrev": false,
"full_module": "Platform.Bytes",
"short_module": null
},
{
"abbrev": true,
"full_module": "EtM.MAC",
"short_module": "MAC"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "EtM",
"short_module": null
},
{
"abbrev": false,
"full_module": "EtM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"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": 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": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | k: EtM.AE.key -> plain: EtM.Plain.plain -> FStar.HyperStack.ST.ST EtM.AE.cipher | FStar.HyperStack.ST.ST | [] | [] | [
"EtM.AE.key",
"EtM.Plain.plain",
"FStar.Pervasives.Native.Mktuple2",
"EtM.CPA.cipher",
"EtM.MAC.tag",
"Prims.unit",
"EtM.AE.mac_only_cpa_ciphers_snoc",
"EtM.AE.get_mac_log",
"EtM.MAC.msg",
"EtM.AE.get_cpa_log",
"EtM.CPA.Entry",
"EtM.AE.mac_and_cpa_refine_ae_snoc",
"EtM.AE.get_log",
"EtM.AE.cipher",
"Prims._assert",
"EtM.CPA.invariant",
"EtM.AE.__proj__Key__item__ke",
"Prims.eq2",
"FStar.Seq.Base.seq",
"EtM.AE.log_entry",
"FStar.Monotonic.HyperStack.sel",
"FStar.Monotonic.Seq.grows",
"EtM.AE.__proj__Key__item__log",
"FStar.Monotonic.Seq.snoc",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"FStar.Monotonic.Seq.write_at_end",
"EtM.AE.__proj__Key__item__region",
"EtM.MAC.mac",
"EtM.AE.__proj__Key__item__km",
"EtM.CPA.encrypt",
"EtM.AE.invariant",
"Prims.l_and",
"FStar.Monotonic.HyperStack.modifies_transitively",
"FStar.Set.singleton",
"FStar.Monotonic.HyperHeap.rid"
] | [] | false | true | false | false | false | let encrypt (k: key) (plain: Plain.plain)
: ST cipher
(requires (fun h0 -> invariant h0 k))
(ensures
(fun h0 c h1 ->
(let log0 = get_log h0 k in
let log1 = get_log h1 k in
modifies_transitively (Set.singleton k.region) h0 h1 /\ invariant h1 k /\
log1 == snoc log0 (plain, c)))) =
| let h0 = FStar.HyperStack.ST.get () in
let c = CPA.encrypt k.ke plain in
let t = MAC.mac k.km c in
write_at_end k.log (plain, (c, t));
let h1 = FStar.HyperStack.ST.get () in
assert (sel h1 k.log == snoc (sel h0 k.log) (plain, (c, t)));
assert (EtM.CPA.invariant (Key?.ke k) h1);
mac_and_cpa_refine_ae_snoc (get_log h0 k)
(get_mac_log h0 k)
(get_cpa_log h0 k)
(plain, (c, t))
(c, t)
(CPA.Entry plain c);
mac_only_cpa_ciphers_snoc (get_mac_log h0 k) (c, t) (get_cpa_log h0 k) (CPA.Entry plain c);
(c, t) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.swriter_ifthenelse | val swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot
(x:
swriter s h0 space_beyond sout pout_from0
{swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ()))}) | val swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot
(x:
swriter s h0 space_beyond sout pout_from0
{swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ()))}) | let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 95,
"end_line": 118,
"start_col": 0,
"start_line": 104
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
cond: Prims.bool ->
wtrue:
(_: Prims.squash (cond == true)
-> LowParse.Low.Writers.swriter s h0 space_beyond sout pout_from0) ->
wfalse:
(_: Prims.squash (cond == false)
-> LowParse.Low.Writers.swriter s h0 space_beyond sout pout_from0)
-> x:
LowParse.Low.Writers.swriter s h0 space_beyond sout pout_from0
{ LowParse.Low.Writers.swvalue x ==
(match cond with
| true -> LowParse.Low.Writers.swvalue (wtrue ())
| _ -> LowParse.Low.Writers.swvalue (wfalse ())) } | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Monotonic.HyperStack.mem",
"Prims.nat",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"Prims.bool",
"Prims.squash",
"LowParse.Low.Writers.swriter",
"LowParse.Low.Writers.SWriter",
"LowParse.Low.Writers.__proj__SWriter__item__v",
"FStar.Ghost.erased",
"LowParse.Low.Writers.swrite",
"LowParse.Low.Writers.swvalue"
] | [] | false | false | false | false | false | let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot
(x:
swriter s h0 space_beyond sout pout_from0
{swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ()))}) =
| SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.swrite | val swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w)) | val swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w)) | let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 33,
"end_line": 100,
"start_col": 0,
"start_line": 89
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | w: LowParse.Low.Writers.swriter s h0 space_beyond sout pout_from0
-> LowParse.Low.Writers.fswriter s
h0
space_beyond
sout
pout_from0
(LowParse.Low.Writers.swvalue w) | Prims.Tot | [
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"Prims.nat",
"LowParse.Low.Writers.swriter",
"FStar.Ghost.erased",
"LowParse.Low.Writers.fswriter",
"FStar.Ghost.reveal",
"LowParse.Low.Writers.swvalue"
] | [] | false | false | false | false | false | let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w)) =
| match w with | SWriter _ f -> f | false |
Spec.SHA3.fst | Spec.SHA3.rotl | val rotl (a: uint64) (b: size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 | val rotl (a: uint64) (b: size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 | let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 17,
"end_line": 26,
"start_col": 0,
"start_line": 25
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false |
a: Lib.IntTypes.uint64 ->
b: Lib.IntTypes.size_t{0 < Lib.IntTypes.uint_v b /\ Lib.IntTypes.uint_v b < 64}
-> Lib.IntTypes.uint64 | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.uint64",
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.uint_v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.rotate_left",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC"
] | [] | false | false | false | false | false | let rotl (a: uint64) (b: size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
| rotate_left a b | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.swrite_leaf | val swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 {swvalue y == x}) | val swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 {swvalue y == x}) | let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 39,
"end_line": 134,
"start_col": 0,
"start_line": 122
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
w: LowParse.Low.Base.leaf_writer_strong s ->
h0: FStar.Monotonic.HyperStack.mem ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
pout_from0: FStar.UInt32.t ->
x: t
-> y: LowParse.Low.Writers.swriter s h0 0 sout pout_from0 {LowParse.Low.Writers.swvalue y == x} | Prims.Tot | [
"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",
"LowParse.Low.Base.leaf_writer_strong",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.SWriter",
"FStar.Ghost.hide",
"LowParse.Low.Writers.swriter",
"LowParse.Low.Writers.swvalue"
] | [] | false | false | false | false | false | let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 {swvalue y == x}) =
| SWriter (Ghost.hide x) (fun pout_from -> w x sout pout_from) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.olwvalue | val olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t)) | val olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t)) | let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 18,
"end_line": 708,
"start_col": 0,
"start_line": 698
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | w: LowParse.Low.Writers.olwriter s h0 sout pout_from0
-> Prims.GTot (FStar.Pervasives.Native.option (Prims.list t)) | Prims.GTot | [
"sometrivial"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.olwriter",
"FStar.Ghost.reveal",
"Prims.list",
"LowParse.Low.Writers.__proj__OLWriter__item__v"
] | [] | false | false | false | false | false | let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t)) =
| Ghost.reveal w.v | false |
Spec.SHA3.fst | Spec.SHA3.state_theta_inner_s_inner | val state_theta_inner_s_inner (x: index) (_D: uint64) (y: index) (s: state) : Tot state | val state_theta_inner_s_inner (x: index) (_D: uint64) (y: index) (s: state) : Tot state | let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D) | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 29,
"end_line": 35,
"start_col": 0,
"start_line": 34
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false | x: Spec.SHA3.index -> _D: Lib.IntTypes.uint64 -> y: Spec.SHA3.index -> s: Spec.SHA3.state
-> Spec.SHA3.state | Prims.Tot | [
"total"
] | [] | [
"Spec.SHA3.index",
"Lib.IntTypes.uint64",
"Spec.SHA3.state",
"Spec.SHA3.set",
"Lib.IntTypes.op_Hat_Dot",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA3.get"
] | [] | false | false | false | true | false | let state_theta_inner_s_inner (x: index) (_D: uint64) (y: index) (s: state) : Tot state =
| set s x y (get s x y ^. _D) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.lwrite | val lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w)) | val lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w)) | let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 33,
"end_line": 353,
"start_col": 0,
"start_line": 343
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | w: LowParse.Low.Writers.lwriter s h0 sout pout_from0
-> LowParse.Low.Writers.flwriter s h0 sout pout_from0 (LowParse.Low.Writers.lwvalue w) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.lwriter",
"FStar.Ghost.erased",
"Prims.list",
"LowParse.Low.Writers.flwriter",
"FStar.Ghost.reveal",
"LowParse.Low.Writers.lwvalue"
] | [] | false | false | false | false | false | let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w)) =
| match w with | LWriter _ f -> f | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.weaken_swriter | val weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w': swriter s h1 space_beyond1 sout pout_from1 {swvalue w' == swvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\
space_beyond0 <= space_beyond1))
(ensures (fun _ -> True)) | val weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w': swriter s h1 space_beyond1 sout pout_from1 {swvalue w' == swvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\
space_beyond0 <= space_beyond1))
(ensures (fun _ -> True)) | let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 46,
"end_line": 85,
"start_col": 0,
"start_line": 69
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
w: LowParse.Low.Writers.swriter s h0 space_beyond0 sout pout_from0 ->
h1: FStar.Monotonic.HyperStack.mem ->
space_beyond1: Prims.nat ->
pout_from1: FStar.UInt32.t
-> Prims.Pure
(w':
LowParse.Low.Writers.swriter s h1 space_beyond1 sout pout_from1
{LowParse.Low.Writers.swvalue w' == LowParse.Low.Writers.swvalue w}) | Prims.Pure | [] | [] | [
"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.Monotonic.HyperStack.mem",
"Prims.nat",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.swriter",
"LowParse.Low.Writers.SWriter",
"LowParse.Low.Writers.__proj__SWriter__item__v",
"LowParse.Low.Writers.__proj__SWriter__item__w",
"LowParse.Low.Writers.swvalue",
"Prims.l_and",
"LowStar.Monotonic.Buffer.modifies",
"LowParse.Slice.loc_slice_from",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.l_True"
] | [] | false | false | false | false | false | let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w': swriter s h1 space_beyond1 sout pout_from1 {swvalue w' == swvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\
space_beyond0 <= space_beyond1))
(ensures (fun _ -> True)) =
| SWriter w.v (fun pout_from -> w.w pout_from) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.write | val write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w)) | val write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w)) | let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 32,
"end_line": 223,
"start_col": 0,
"start_line": 213
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | w: LowParse.Low.Writers.writer s h0 sout pout_from0
-> LowParse.Low.Writers.fwriter s h0 sout pout_from0 (LowParse.Low.Writers.wvalue w) | Prims.Tot | [
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.writer",
"FStar.Ghost.erased",
"LowParse.Low.Writers.fwriter",
"FStar.Ghost.reveal",
"LowParse.Low.Writers.wvalue"
] | [] | false | false | false | false | false | let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w)) =
| match w with | Writer _ f -> f | false |
Steel.PCMFrac.fst | Steel.PCMFrac.pcm_frac | val pcm_frac (#a: _) : pcm (fractional a) | val pcm_frac (#a: _) : pcm (fractional a) | let pcm_frac #a : pcm (fractional a) = {
p = {
composable = composable;
op = compose;
one = None
};
comm = (fun _ _ -> ());
assoc = (fun _ _ _ -> ());
assoc_r = (fun _ _ _ -> ());
is_unit = (fun _ -> ());
refine = (fun _ -> True)
} | {
"file_name": "lib/steel/Steel.PCMFrac.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 1,
"end_line": 30,
"start_col": 0,
"start_line": 19
} | module Steel.PCMFrac
include FStar.PCM
include Steel.FractionalPermission
open FStar.Real
let fractional (a:Type u#a) = option (a & perm)
let composable #a : symrel (fractional a) =
fun (f0 f1:fractional a) ->
match f0, f1 with
| None, _
| _, None -> True
| Some (x0, p0), Some (x1, p1) -> x0==x1 /\ (sum_perm p0 p1).v <=. one
let compose #a (f0:fractional a) (f1:fractional a{composable f0 f1}) : fractional a =
match f0, f1 with
| None, f
| f, None -> f
| Some (x0, p0), Some (_, p1) -> Some (x0, sum_perm p0 p1) | {
"checked_file": "/",
"dependencies": [
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.PCMFrac.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | FStar.PCM.pcm (Steel.PCMFrac.fractional a) | Prims.Tot | [
"total"
] | [] | [
"FStar.PCM.Mkpcm",
"Steel.PCMFrac.fractional",
"FStar.PCM.Mkpcm'",
"Steel.PCMFrac.composable",
"Steel.PCMFrac.compose",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.tuple2",
"Steel.FractionalPermission.perm",
"FStar.PCM.__proj__Mkpcm'__item__composable",
"Prims.unit",
"Prims.l_and",
"FStar.PCM.__proj__Mkpcm'__item__op",
"Prims.l_True",
"Prims.prop",
"FStar.PCM.pcm"
] | [] | false | false | false | true | false | let pcm_frac #a : pcm (fractional a) =
| {
p = { composable = composable; op = compose; one = None };
comm = (fun _ _ -> ());
assoc = (fun _ _ _ -> ());
assoc_r = (fun _ _ _ -> ());
is_unit = (fun _ -> ());
refine = (fun _ -> True)
} | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.grvalue | val grvalue
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t | val grvalue
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t | let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 29,
"end_line": 932,
"start_col": 0,
"start_line": 925
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: LowParse.Low.Writers.greader h0 sout pout_from0 t -> Prims.GTot t | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.greader",
"FStar.Ghost.reveal",
"LowParse.Low.Writers.__proj__GReader__item__v"
] | [] | false | false | false | false | false | let grvalue
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t =
| Ghost.reveal (GReader?.v r) | false |
Steel.Primitive.ForkJoin.Unix.fst | Steel.Primitive.ForkJoin.Unix.as_steelk_repr | val as_steelk_repr
(a: Type)
(pre: pre_t)
(post: post_t a)
(f: repr a false pre post (triv_pre pre) (triv_post pre post))
: steelK a false pre post | val as_steelk_repr
(a: Type)
(pre: pre_t)
(post: post_t a)
(f: repr a false pre post (triv_pre pre) (triv_post pre post))
: steelK a false pre post | let as_steelk_repr (a:Type) (pre:pre_t) (post:post_t a)
(f:repr a false pre post (triv_pre pre) (triv_post pre post))// unit -> SteelT a pre post)
: steelK a false pre post
= as_steelk_repr' a pre post (fun _ -> SteelBase?.reflect f) | {
"file_name": "lib/steel/Steel.Primitive.ForkJoin.Unix.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 62,
"end_line": 237,
"start_col": 0,
"start_line": 234
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Primitive.ForkJoin.Unix
(* This module shows that it's possible to layer continuations on top
of SteelT to get a direct style (or Unix style) fork/join. Very much a
prototype for now. *)
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open Steel.Reference
open Steel.Primitive.ForkJoin
#set-options "--warn_error -330" //turn off the experimental feature warning
#set-options "--ide_id_info_off"
// (* Some helpers *)
let change_slprop_equiv (p q : vprop)
(proof : squash (p `equiv` q))
: SteelT unit p (fun _ -> q)
= rewrite_slprop p q (fun _ -> proof; reveal_equiv p q)
let change_slprop_imp (p q : vprop)
(proof : squash (p `can_be_split` q))
: SteelT unit p (fun _ -> q)
= rewrite_slprop p q (fun _ -> proof; reveal_can_be_split ())
(* Continuations into unit, but parametrized by the final heap
* proposition and with an implicit framing. I think ideally these would
* also be parametric in the final type (instead of being hardcoded to
* unit) but that means fork needs to be extended to be polymorphic in
* at least one of the branches. *)
type steelK (t:Type u#aa) (framed:bool) (pre : vprop) (post:t->vprop) =
#frame:vprop -> #postf:vprop ->
f:(x:t -> SteelT unit (frame `star` post x) (fun _ -> postf)) ->
SteelT unit (frame `star` pre) (fun _ -> postf)
(* The classic continuation monad *)
let return_ a (x:a) (#[@@@ framing_implicit] p: a -> vprop) : steelK a true (return_pre (p x)) p =
fun k -> k x
private
let rearrange3 (p q r:vprop) : Lemma
(((p `star` q) `star` r) `equiv` (p `star` (r `star` q)))
= let open FStar.Tactics in
assert (((p `star` q) `star` r) `equiv` (p `star` (r `star` q))) by
(norm [delta_attr [`%__reduce__]]; canon' false (`true_p) (`true_p))
private
let equiv_symmetric (p1 p2:vprop)
: Lemma (requires p1 `equiv` p2) (ensures p2 `equiv` p1)
= reveal_equiv p1 p2;
equiv_symmetric (hp_of p1) (hp_of p2);
reveal_equiv p2 p1
private
let can_be_split_forall_frame (#a:Type) (p q:post_t a) (frame:vprop) (x:a)
: Lemma (requires can_be_split_forall p q)
(ensures (frame `star` p x) `can_be_split` (frame `star` q x))
= let frame = hp_of frame in
let p = hp_of (p x) in
let q = hp_of (q x) in
reveal_can_be_split ();
assert (slimp p q);
slimp_star p q frame frame;
Steel.Memory.star_commutative p frame;
Steel.Memory.star_commutative q frame
let bind (a:Type) (b:Type)
(#framed_f:eqtype_as_type bool) (#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] pre_g:a -> pre_t) (#[@@@ framing_implicit] post_g:post_t b)
(#[@@@ framing_implicit] frame_f:vprop) (#[@@@ framing_implicit] frame_g:vprop)
(#[@@@ framing_implicit] p:squash (can_be_split_forall
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g)))
(#[@@@ framing_implicit] m1 : squash (maybe_emp framed_f frame_f))
(#[@@@ framing_implicit] m2:squash (maybe_emp framed_g frame_g))
(f:steelK a framed_f pre_f post_f)
(g:(x:a -> steelK b framed_g (pre_g x) post_g))
: steelK b
true
(pre_f `star` frame_f)
(fun y -> post_g y `star` frame_g)
= fun #frame (#post:vprop) (k:(y:b -> SteelT unit (frame `star` (post_g y `star` frame_g)) (fun _ -> post))) ->
// Need SteelT unit (frame `star` (pre_f `star` frame_f)) (fun _ -> post)
change_slprop_equiv (frame `star` (pre_f `star` frame_f)) ((frame `star` frame_f) `star` pre_f) (rearrange3 frame frame_f pre_f;
equiv_symmetric ((frame `star` frame_f) `star` pre_f) (frame `star` (pre_f `star` frame_f)) );
f #(frame `star` frame_f) #post
((fun (x:a) ->
// Need SteelT unit ((frame `star` frame_f) `star` post_f x) (fun _ -> post)
change_slprop_imp
(frame `star` (post_f x `star` frame_f))
(frame `star` (pre_g x `star` frame_g))
(can_be_split_forall_frame (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g) frame x);
g x #(frame `star` frame_g) #post
((fun (y:b) -> k y)
<: (y:b -> SteelT unit ((frame `star` frame_g) `star` post_g y) (fun _ -> post)))
)
<: (x:a -> SteelT unit ((frame `star` frame_f) `star` post_f x) (fun _ -> post)))
let subcomp (a:Type)
(#framed_f:eqtype_as_type bool) (#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] p1:squash (can_be_split pre_g pre_f))
(#[@@@ framing_implicit] p2:squash (can_be_split_forall post_f post_g))
(f:steelK a framed_f pre_f post_f)
: Tot (steelK a framed_g pre_g post_g)
= fun #frame #postf (k:(x:a -> SteelT unit (frame `star` post_g x) (fun _ -> postf))) ->
change_slprop_imp pre_g pre_f ();
f #frame #postf ((fun x -> change_slprop_imp (frame `star` post_f x) (frame `star` post_g x)
(can_be_split_forall_frame post_f post_g frame x);
k x) <: (x:a -> SteelT unit (frame `star` post_f x) (fun _ -> postf)))
// let if_then_else (a:Type u#aa)
// (#[@@@ framing_implicit] pre1:pre_t)
// (#[@@@ framing_implicit] post1:post_t a)
// (f : steelK a pre1 post1)
// (g : steelK a pre1 post1)
// (p:Type0) : Type =
// steelK a pre1 post1
// We did not define a bind between Div and Steel, so we indicate
// SteelKF as total to be able to reify and compose it when implementing fork
// This module is intended as proof of concept
total
reifiable
reflectable
layered_effect {
SteelKBase : a:Type -> framed:bool -> pre:vprop -> post:(a->vprop) -> Effect
with
repr = steelK;
return = return_;
bind = bind;
subcomp = subcomp
// if_then_else = if_then_else
}
effect SteelK (a:Type) (pre:pre_t) (post:post_t a) =
SteelKBase a false pre post
effect SteelKF (a:Type) (pre:pre_t) (post:post_t a) =
SteelKBase a true pre post
// We would need requires/ensures in SteelK to have a binding with Pure.
// But for our example, Tot is here sufficient
let bind_tot_steelK_ (a:Type) (b:Type)
(#framed:eqtype_as_type bool)
(#[@@@ framing_implicit] pre:pre_t) (#[@@@ framing_implicit] post:post_t b)
(f:eqtype_as_type unit -> Tot a) (g:(x:a -> steelK b framed pre post))
: steelK b
framed
pre
post
= fun #frame #postf (k:(x:b -> SteelT unit (frame `star` post x) (fun _ -> postf))) ->
let x = f () in
g x #frame #postf k
polymonadic_bind (PURE, SteelKBase) |> SteelKBase = bind_tot_steelK_
// (* Sanity check *)
let test_lift #p #q (f : unit -> SteelK unit p (fun _ -> q)) : SteelK unit p (fun _ -> q) =
();
f ();
()
(* Identity cont with frame, to eliminate a SteelK *)
let idk (#frame:vprop) (#a:Type) (x:a) : SteelT a frame (fun x -> frame)
= noop(); return x
let kfork (#p:vprop) (#q:vprop) (f : unit -> SteelK unit p (fun _ -> q))
: SteelK (thread q) p (fun _ -> emp)
=
SteelK?.reflect (
fun (#frame:vprop) (#postf:vprop)
(k : (x:(thread q) -> SteelT unit (frame `star` emp) (fun _ -> postf))) ->
noop ();
let t1 () : SteelT unit (emp `star` p) (fun _ -> q) =
let r : steelK unit false p (fun _ -> q) = reify (f ()) in
r #emp #q (fun _ -> idk())
in
let t2 (t:thread q) () : SteelT unit frame (fun _ -> postf) = k t in
let ff () : SteelT unit (p `star` frame) (fun _ -> postf) =
fork #p #q #frame #postf t1 t2
in
ff())
let kjoin (#p:vprop) (t : thread p) : SteelK unit emp (fun _ -> p)
= SteelK?.reflect (fun #f k -> join t; k ())
(* Example *)
assume val q : int -> vprop
assume val f : unit -> SteelK unit emp (fun _ -> emp)
assume val g : i:int -> SteelK unit emp (fun _ -> q i)
assume val h : unit -> SteelK unit emp (fun _ -> emp)
let example () : SteelK unit emp (fun _ -> q 1 `star` q 2) =
let p1:thread (q 1) = kfork (fun () -> g 1) in
let p2:thread (q 2) = kfork (fun () -> g 2) in
kjoin p1;
h();
kjoin p2
let as_steelk_repr' (a:Type) (pre:pre_t) (post:post_t a) (f:unit -> SteelT a pre post)
: steelK a false pre post
= fun #frame #postf (k:(x:a -> SteelT unit (frame `star` post x) (fun _ -> postf))) ->
let x = f () in
k x
let triv_pre (req:vprop) : req_t req = fun _ -> True
let triv_post (#a:Type) (req:vprop) (ens:post_t a) : ens_t req a ens = fun _ _ _ -> True | {
"checked_file": "/",
"dependencies": [
"Steel.Reference.fsti.checked",
"Steel.Primitive.ForkJoin.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.Primitive.ForkJoin.Unix.fst"
} | [
{
"abbrev": false,
"full_module": "Steel.Primitive.ForkJoin",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive.ForkJoin",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive.ForkJoin",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Type ->
pre: Steel.Effect.Common.pre_t ->
post: Steel.Effect.Common.post_t a ->
f:
Steel.Effect.repr a
false
pre
post
(Steel.Primitive.ForkJoin.Unix.triv_pre pre)
(Steel.Primitive.ForkJoin.Unix.triv_post pre post)
-> Steel.Primitive.ForkJoin.Unix.steelK a false pre post | Prims.Tot | [
"total"
] | [] | [
"Steel.Effect.Common.pre_t",
"Steel.Effect.Common.post_t",
"Steel.Effect.repr",
"Steel.Primitive.ForkJoin.Unix.triv_pre",
"Steel.Primitive.ForkJoin.Unix.triv_post",
"Steel.Primitive.ForkJoin.Unix.as_steelk_repr'",
"Prims.unit",
"Steel.Primitive.ForkJoin.Unix.steelK"
] | [] | false | false | false | false | false | let as_steelk_repr
(a: Type)
(pre: pre_t)
(post: post_t a)
(f: repr a false pre post (triv_pre pre) (triv_post pre post))
: steelK a false pre post =
| as_steelk_repr' a pre post (fun _ -> SteelBase?.reflect f) | false |
Spec.SHA3.fst | Spec.SHA3.state_pi_rho_s | val state_pi_rho_s: i:size_nat{i <= 24} -> Type0 | val state_pi_rho_s: i:size_nat{i <= 24} -> Type0 | let state_pi_rho_s i = uint64 & state | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 37,
"end_line": 58,
"start_col": 0,
"start_line": 58
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false | i: Lib.IntTypes.size_nat{i <= 24} -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Pervasives.Native.tuple2",
"Lib.IntTypes.uint64",
"Spec.SHA3.state"
] | [] | false | false | false | false | true | let state_pi_rho_s i =
| uint64 & state | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.lwriter_nil | val lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 {lwvalue x == []}) | val lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 {lwvalue x == []}) | let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 371,
"start_col": 0,
"start_line": 357
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
s:
LowParse.Spec.Base.serializer p
{ Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
Mkparser_kind'?.parser_kind_low k > 0 } ->
h0: FStar.Monotonic.HyperStack.mem ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
pout_from0: FStar.UInt32.t
-> x: LowParse.Low.Writers.lwriter s h0 sout pout_from0 {LowParse.Low.Writers.lwvalue x == []} | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.LWriter",
"FStar.Ghost.hide",
"Prims.list",
"Prims.Nil",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_list_nil",
"FStar.HyperStack.ST.get",
"LowParse.Low.Writers.lwriter",
"LowParse.Low.Writers.lwvalue"
] | [] | false | false | false | false | false | let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 {lwvalue x == []}) =
| LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.writer_ifthenelse | val writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot
(x:
writer s h0 sout pout_from0
{wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ()))}) | val writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot
(x:
writer s h0 sout pout_from0
{wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ()))}) | let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 93,
"end_line": 240,
"start_col": 0,
"start_line": 227
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
cond: Prims.bool ->
wtrue: (_: Prims.squash (cond == true) -> LowParse.Low.Writers.writer s h0 sout pout_from0) ->
wfalse: (_: Prims.squash (cond == false) -> LowParse.Low.Writers.writer s h0 sout pout_from0)
-> x:
LowParse.Low.Writers.writer s h0 sout pout_from0
{ LowParse.Low.Writers.wvalue x ==
(match cond with
| true -> LowParse.Low.Writers.wvalue (wtrue ())
| _ -> LowParse.Low.Writers.wvalue (wfalse ())) } | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"Prims.bool",
"Prims.squash",
"LowParse.Low.Writers.writer",
"LowParse.Low.Writers.Writer",
"LowParse.Low.Writers.__proj__Writer__item__v",
"FStar.Ghost.erased",
"LowParse.Low.Writers.write",
"LowParse.Low.Writers.wvalue"
] | [] | false | false | false | false | false | let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot
(x:
writer s h0 sout pout_from0
{wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ()))}) =
| Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.weaken_writer | val weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': writer s h1 sout pout_from1 {wvalue w' == wvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) | val weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': writer s h1 sout pout_from1 {wvalue w' == wvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) | let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 45,
"end_line": 209,
"start_col": 0,
"start_line": 195
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
w: LowParse.Low.Writers.writer s h0 sout pout_from0 ->
h1: FStar.Monotonic.HyperStack.mem ->
pout_from1: FStar.UInt32.t
-> Prims.Pure
(w':
LowParse.Low.Writers.writer s h1 sout pout_from1
{LowParse.Low.Writers.wvalue w' == LowParse.Low.Writers.wvalue w}) | Prims.Pure | [] | [] | [
"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.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.writer",
"LowParse.Low.Writers.Writer",
"LowParse.Low.Writers.__proj__Writer__item__v",
"LowParse.Low.Writers.__proj__Writer__item__w",
"LowParse.Low.Writers.wvalue",
"Prims.l_and",
"LowStar.Monotonic.Buffer.modifies",
"LowParse.Slice.loc_slice_from",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.l_True"
] | [] | false | false | false | false | false | let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': writer s h1 sout pout_from1 {wvalue w' == wvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) =
| Writer w.v (fun pout_from -> w.w pout_from) | false |
Spec.SHA3.fst | Spec.SHA3.state_permute1 | val state_permute1 (round: size_nat{round < 24}) (s: state) : Tot state | val state_permute1 (round: size_nat{round < 24}) (s: state) : Tot state | let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 8,
"end_line": 87,
"start_col": 0,
"start_line": 82
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round]) | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false | round: Lib.IntTypes.size_nat{round < 24} -> s: Spec.SHA3.state -> Spec.SHA3.state | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThan",
"Spec.SHA3.state",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA3.state_iota",
"Spec.SHA3.state_chi",
"Spec.SHA3.state_pi_rho",
"Spec.SHA3.state_theta"
] | [] | false | false | false | false | false | let state_permute1 (round: size_nat{round < 24}) (s: state) : Tot state =
| let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.weaken_lwriter | val weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': lwriter s h1 sout pout_from1 {lwvalue w' == lwvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) | val weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': lwriter s h1 sout pout_from1 {lwvalue w' == lwvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) | let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 46,
"end_line": 339,
"start_col": 0,
"start_line": 325
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
w: LowParse.Low.Writers.lwriter s h0 sout pout_from0 ->
h1: FStar.Monotonic.HyperStack.mem ->
pout_from1: FStar.UInt32.t
-> Prims.Pure
(w':
LowParse.Low.Writers.lwriter s h1 sout pout_from1
{LowParse.Low.Writers.lwvalue w' == LowParse.Low.Writers.lwvalue w}) | Prims.Pure | [] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.lwriter",
"LowParse.Low.Writers.LWriter",
"LowParse.Low.Writers.__proj__LWriter__item__v",
"LowParse.Low.Writers.__proj__LWriter__item__w",
"Prims.list",
"LowParse.Low.Writers.lwvalue",
"LowStar.Monotonic.Buffer.modifies",
"LowParse.Slice.loc_slice_from",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.l_True"
] | [] | false | false | false | false | false | let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': lwriter s h1 sout pout_from1 {lwvalue w' == lwvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) =
| LWriter w.v (fun pout_from -> w.w pout_from) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.write_leaf_cs | val write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s:
serializer p
{ k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 })
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 {wvalue y == x}) | val write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s:
serializer p
{ k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 })
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 {wvalue y == x}) | let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 260,
"start_col": 0,
"start_line": 244
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
w: LowParse.Low.Base.leaf_writer_strong s ->
h0: FStar.Monotonic.HyperStack.mem ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
pout_from0: FStar.UInt32.t ->
x: t
-> y: LowParse.Low.Writers.writer s h0 sout pout_from0 {LowParse.Low.Writers.wvalue y == x} | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.nat",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"Prims.b2t",
"Prims.op_LessThan",
"LowParse.Low.Base.leaf_writer_strong",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.Writer",
"FStar.Ghost.hide",
"FStar.UInt32.gt",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.sub",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Low.ErrorCode.max_uint32",
"Prims.bool",
"LowParse.Low.Writers.writer",
"LowParse.Low.Writers.wvalue"
] | [] | false | false | false | false | false | let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s:
serializer p
{ k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 })
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 {wvalue y == x}) =
| Writer (Ghost.hide x)
(fun pout_from ->
if (U32.uint_to_t k.parser_kind_low) `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from) | false |
Spec.SHA3.fst | Spec.SHA3.set | val set (s: state) (x y: index) (v: uint64) : Tot state | val set (s: state) (x y: index) (v: uint64) : Tot state | let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 20,
"end_line": 23,
"start_col": 0,
"start_line": 22
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y] | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false | s: Spec.SHA3.state -> x: Spec.SHA3.index -> y: Spec.SHA3.index -> v: Lib.IntTypes.uint64
-> Spec.SHA3.state | Prims.Tot | [
"total"
] | [] | [
"Spec.SHA3.state",
"Spec.SHA3.index",
"Lib.IntTypes.uint64",
"Lib.Sequence.op_String_Assignment",
"Prims.op_Addition",
"FStar.Mul.op_Star"
] | [] | false | false | false | true | false | let set (s: state) (x y: index) (v: uint64) : Tot state =
| s.[ x + 5 * y ] <- v | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.owrite | val owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w)) | val owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w)) | let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 33,
"end_line": 593,
"start_col": 0,
"start_line": 583
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | w: LowParse.Low.Writers.owriter s h0 sout pout_from0
-> LowParse.Low.Writers.fowriter s h0 sout pout_from0 (LowParse.Low.Writers.owvalue w) | Prims.Tot | [
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.owriter",
"FStar.Ghost.erased",
"LowParse.Low.Writers.fowriter",
"FStar.Ghost.reveal",
"LowParse.Low.Writers.owvalue"
] | [] | false | false | false | false | false | let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w)) =
| match w with | OWriter _ f -> f | false |
Steel.Primitive.ForkJoin.Unix.fst | Steel.Primitive.ForkJoin.Unix.return_ | val return_ (a: _) (x: a) (#[@@@ framing_implicit]p: (a -> vprop))
: steelK a true (return_pre (p x)) p | val return_ (a: _) (x: a) (#[@@@ framing_implicit]p: (a -> vprop))
: steelK a true (return_pre (p x)) p | let return_ a (x:a) (#[@@@ framing_implicit] p: a -> vprop) : steelK a true (return_pre (p x)) p =
fun k -> k x | {
"file_name": "lib/steel/Steel.Primitive.ForkJoin.Unix.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 14,
"end_line": 56,
"start_col": 0,
"start_line": 55
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Primitive.ForkJoin.Unix
(* This module shows that it's possible to layer continuations on top
of SteelT to get a direct style (or Unix style) fork/join. Very much a
prototype for now. *)
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open Steel.Reference
open Steel.Primitive.ForkJoin
#set-options "--warn_error -330" //turn off the experimental feature warning
#set-options "--ide_id_info_off"
// (* Some helpers *)
let change_slprop_equiv (p q : vprop)
(proof : squash (p `equiv` q))
: SteelT unit p (fun _ -> q)
= rewrite_slprop p q (fun _ -> proof; reveal_equiv p q)
let change_slprop_imp (p q : vprop)
(proof : squash (p `can_be_split` q))
: SteelT unit p (fun _ -> q)
= rewrite_slprop p q (fun _ -> proof; reveal_can_be_split ())
(* Continuations into unit, but parametrized by the final heap
* proposition and with an implicit framing. I think ideally these would
* also be parametric in the final type (instead of being hardcoded to
* unit) but that means fork needs to be extended to be polymorphic in
* at least one of the branches. *)
type steelK (t:Type u#aa) (framed:bool) (pre : vprop) (post:t->vprop) =
#frame:vprop -> #postf:vprop ->
f:(x:t -> SteelT unit (frame `star` post x) (fun _ -> postf)) ->
SteelT unit (frame `star` pre) (fun _ -> postf) | {
"checked_file": "/",
"dependencies": [
"Steel.Reference.fsti.checked",
"Steel.Primitive.ForkJoin.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.Primitive.ForkJoin.Unix.fst"
} | [
{
"abbrev": false,
"full_module": "Steel.Primitive.ForkJoin",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive.ForkJoin",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive.ForkJoin",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Type -> x: a
-> Steel.Primitive.ForkJoin.Unix.steelK a true (Steel.Effect.Common.return_pre (p x)) p | Prims.Tot | [
"total"
] | [] | [
"Steel.Effect.Common.vprop",
"Prims.unit",
"Steel.Effect.Common.star",
"Steel.Primitive.ForkJoin.Unix.steelK",
"Steel.Effect.Common.return_pre"
] | [] | false | false | false | false | false | let return_ a (x: a) (#[@@@ framing_implicit]p: (a -> vprop)) : steelK a true (return_pre (p x)) p =
| fun k -> k x | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.weaken_olwriter | val weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': olwriter s h1 sout pout_from1 {olwvalue w' == olwvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) | val weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': olwriter s h1 sout pout_from1 {olwvalue w' == olwvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) | let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 47,
"end_line": 726,
"start_col": 0,
"start_line": 712
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
w: LowParse.Low.Writers.olwriter s h0 sout pout_from0 ->
h1: FStar.Monotonic.HyperStack.mem ->
pout_from1: FStar.UInt32.t
-> Prims.Pure
(w':
LowParse.Low.Writers.olwriter s h1 sout pout_from1
{LowParse.Low.Writers.olwvalue w' == LowParse.Low.Writers.olwvalue w}) | Prims.Pure | [] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.olwriter",
"LowParse.Low.Writers.OLWriter",
"LowParse.Low.Writers.__proj__OLWriter__item__v",
"LowParse.Low.Writers.__proj__OLWriter__item__w",
"Prims.list",
"LowParse.Low.Writers.olwvalue",
"LowStar.Monotonic.Buffer.modifies",
"LowParse.Slice.loc_slice_from",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.l_True"
] | [] | false | false | false | false | false | let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': olwriter s h1 sout pout_from1 {olwvalue w' == olwvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) =
| OLWriter w.v (fun pout_from -> w.w pout_from) | false |
Spec.SHA3.fst | Spec.SHA3.get | val get (s: state) (x y: index) : Tot uint64 | val get (s: state) (x y: index) : Tot uint64 | let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y] | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 20,
"start_col": 0,
"start_line": 19
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5} | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false | s: Spec.SHA3.state -> x: Spec.SHA3.index -> y: Spec.SHA3.index -> Lib.IntTypes.uint64 | Prims.Tot | [
"total"
] | [] | [
"Spec.SHA3.state",
"Spec.SHA3.index",
"Lib.Sequence.op_String_Access",
"Lib.IntTypes.uint64",
"Prims.op_Addition",
"FStar.Mul.op_Star"
] | [] | false | false | false | true | false | let get (s: state) (x y: index) : Tot uint64 =
| s.[ x + 5 * y ] | false |
Spec.SHA3.fst | Spec.SHA3.state_theta0 | val state_theta0 : s: Spec.SHA3.state -> _C: Lib.Sequence.lseq Lib.IntTypes.uint64 5
-> Lib.Sequence.lseq Lib.IntTypes.uint64 5 | let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 32,
"start_col": 0,
"start_line": 31
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4 | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false | s: Spec.SHA3.state -> _C: Lib.Sequence.lseq Lib.IntTypes.uint64 5
-> Lib.Sequence.lseq Lib.IntTypes.uint64 5 | Prims.Tot | [
"total"
] | [] | [
"Spec.SHA3.state",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Lib.LoopCombinators.repeati",
"Spec.SHA3.state_theta_inner_C"
] | [] | false | false | false | false | false | let state_theta0 (s: state) (_C: lseq uint64 5) =
| repeati 5 (state_theta_inner_C s) _C | false |
|
LowParse.Low.Writers.fst | LowParse.Low.Writers.lwriter_singleton | val lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 {lwvalue x == [wvalue w]}) | val lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 {lwvalue x == [wvalue w]}) | let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 402,
"start_col": 0,
"start_line": 375
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | w: LowParse.Low.Writers.writer s h0 sout pout_from0
-> x:
LowParse.Low.Writers.lwriter s h0 sout pout_from0
{LowParse.Low.Writers.lwvalue x == [LowParse.Low.Writers.wvalue w]} | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.writer",
"LowParse.Low.Writers.LWriter",
"FStar.Ghost.hide",
"Prims.list",
"Prims.Cons",
"LowParse.Low.Writers.wvalue",
"Prims.Nil",
"Prims.unit",
"FStar.UInt32.lt",
"LowParse.Low.ErrorCode.max_uint32",
"LowParse.Low.Base.Spec.valid_list_cons",
"LowParse.Low.Base.Spec.valid_list_nil",
"FStar.HyperStack.ST.get",
"Prims.bool",
"Prims.l_True",
"Prims.squash",
"Prims.nat",
"LowParse.Low.Base.Spec.serialized_list_length",
"LowParse.Low.Base.Spec.serialized_length",
"FStar.Pervasives.pattern",
"LowParse.Low.Base.Spec.serialized_list_length_nil",
"LowParse.Low.Base.Spec.serialized_list_length_cons",
"LowParse.Low.Writers.write",
"LowParse.Low.Writers.lwriter",
"LowParse.Low.Writers.lwvalue"
] | [] | false | false | false | false | false | let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 {lwvalue x == [wvalue w]}) =
| LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
else
([@@ inline_let ]let f ()
: Lemma
(ensures
(let v = wvalue w in
serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ());
res) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.owriter_ifthenelse | val owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot
(x:
owriter s h0 sout pout_from0
{owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ()))}) | val owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot
(x:
owriter s h0 sout pout_from0
{owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ()))}) | let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 95,
"end_line": 610,
"start_col": 0,
"start_line": 597
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
cond: Prims.bool ->
wtrue: (_: Prims.squash (cond == true) -> LowParse.Low.Writers.owriter s h0 sout pout_from0) ->
wfalse: (_: Prims.squash (cond == false) -> LowParse.Low.Writers.owriter s h0 sout pout_from0)
-> x:
LowParse.Low.Writers.owriter s h0 sout pout_from0
{ LowParse.Low.Writers.owvalue x ==
(match cond with
| true -> LowParse.Low.Writers.owvalue (wtrue ())
| _ -> LowParse.Low.Writers.owvalue (wfalse ())) } | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"Prims.bool",
"Prims.squash",
"LowParse.Low.Writers.owriter",
"LowParse.Low.Writers.OWriter",
"LowParse.Low.Writers.__proj__OWriter__item__v",
"FStar.Ghost.erased",
"LowParse.Low.Writers.owrite",
"LowParse.Low.Writers.owvalue"
] | [] | false | false | false | false | false | let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot
(x:
owriter s h0 sout pout_from0
{owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ()))}) =
| OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.lwriter_append | val lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot
(x: lwriter s h0 sout pout_from0 {lwvalue x == (lwvalue w1) `List.Tot.append` (lwvalue w2)}) | val lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot
(x: lwriter s h0 sout pout_from0 {lwvalue x == (lwvalue w1) `List.Tot.append` (lwvalue w2)}) | let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 434,
"start_col": 0,
"start_line": 406
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
w1: LowParse.Low.Writers.lwriter s h0 sout pout_from0 ->
w2: LowParse.Low.Writers.lwriter s h0 sout pout_from0
-> x:
LowParse.Low.Writers.lwriter s h0 sout pout_from0
{ LowParse.Low.Writers.lwvalue x ==
LowParse.Low.Writers.lwvalue w1 @ LowParse.Low.Writers.lwvalue w2 } | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.lwriter",
"LowParse.Low.Writers.LWriter",
"FStar.Ghost.hide",
"Prims.list",
"FStar.List.Tot.Base.append",
"LowParse.Low.Writers.lwvalue",
"Prims.op_Equality",
"LowParse.Low.ErrorCode.max_uint32",
"Prims.bool",
"Prims.unit",
"FStar.UInt32.lt",
"LowParse.Low.Base.Spec.valid_list_serialized_list_length",
"LowParse.Low.Base.Spec.valid_list_append",
"FStar.HyperStack.ST.get",
"LowParse.Low.Writers.lwrite",
"FStar.Classical.forall_intro_2",
"Prims.int",
"LowParse.Low.Base.Spec.serialized_list_length",
"Prims.op_Addition",
"LowParse.Low.Base.Spec.serialized_list_length_append"
] | [] | false | false | false | false | false | let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot
(x: lwriter s h0 sout pout_from0 {lwvalue x == (lwvalue w1) `List.Tot.append` (lwvalue w2)}) =
| LWriter (Ghost.hide ((lwvalue w1) `List.Tot.append` (lwvalue w2)))
(fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then res1
else
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then
(valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2);
res2) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.owriter_of_writer | val owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 {owvalue x == Some (wvalue w)}) | val owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 {owvalue x == Some (wvalue w)}) | let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 77,
"end_line": 644,
"start_col": 0,
"start_line": 634
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | w: LowParse.Low.Writers.writer s h0 sout pout_from0
-> x:
LowParse.Low.Writers.owriter s h0 sout pout_from0
{ LowParse.Low.Writers.owvalue x ==
FStar.Pervasives.Native.Some (LowParse.Low.Writers.wvalue w) } | Prims.Tot | [
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.writer",
"LowParse.Low.Writers.OWriter",
"FStar.Ghost.hide",
"LowParse.Low.Writers.wvalue",
"LowParse.Low.Writers.write",
"LowParse.Low.Writers.owriter",
"LowParse.Low.Writers.owvalue"
] | [] | false | false | false | false | false | let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 {owvalue x == Some (wvalue w)}) =
| OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.olwrite | val olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w)) | val olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w)) | let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 34,
"end_line": 740,
"start_col": 0,
"start_line": 730
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | w: LowParse.Low.Writers.olwriter s h0 sout pout_from0
-> LowParse.Low.Writers.folwriter s h0 sout pout_from0 (LowParse.Low.Writers.olwvalue w) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.olwriter",
"FStar.Ghost.erased",
"Prims.list",
"LowParse.Low.Writers.folwriter",
"FStar.Ghost.reveal",
"LowParse.Low.Writers.olwvalue"
] | [] | false | false | false | false | false | let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w)) =
| match w with | OLWriter _ f -> f | false |
Spec.SHA3.fst | Spec.SHA3.state_chi_inner0 | val state_chi_inner0 (s_pi_rho: state) (y x: index) (s: state) : Tot state | val state_chi_inner0 (s_pi_rho: state) (y x: index) (s: state) : Tot state | let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y)) | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 71,
"start_col": 0,
"start_line": 67
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false | s_pi_rho: Spec.SHA3.state -> y: Spec.SHA3.index -> x: Spec.SHA3.index -> s: Spec.SHA3.state
-> Spec.SHA3.state | Prims.Tot | [
"total"
] | [] | [
"Spec.SHA3.state",
"Spec.SHA3.index",
"Spec.SHA3.set",
"Lib.IntTypes.op_Hat_Dot",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA3.get",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.lognot",
"Prims.op_Modulus",
"Prims.op_Addition"
] | [] | false | false | false | true | false | let state_chi_inner0 (s_pi_rho: state) (y x: index) (s: state) : Tot state =
| set s
x
y
(get s_pi_rho x y ^. ((lognot (get s_pi_rho ((x + 1) % 5) y)) &. get s_pi_rho ((x + 2) % 5) y)) | false |
Spec.SHA3.fst | Spec.SHA3.state_chi | val state_chi (s_pi_rho: state) : Tot state | val state_chi (s_pi_rho: state) : Tot state | let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 77,
"start_col": 0,
"start_line": 76
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false | s_pi_rho: Spec.SHA3.state -> Spec.SHA3.state | Prims.Tot | [
"total"
] | [] | [
"Spec.SHA3.state",
"Lib.LoopCombinators.repeati",
"Spec.SHA3.state_chi_inner1"
] | [] | false | false | false | true | false | let state_chi (s_pi_rho: state) : Tot state =
| repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho | false |
Spec.SHA3.fst | Spec.SHA3.state_chi_inner1 | val state_chi_inner1 (s_pi_rho: state) (y: index) (s: state) : Tot state | val state_chi_inner1 (s_pi_rho: state) (y: index) (s: state) : Tot state | let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 43,
"end_line": 74,
"start_col": 0,
"start_line": 73
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y)) | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false | s_pi_rho: Spec.SHA3.state -> y: Spec.SHA3.index -> s: Spec.SHA3.state -> Spec.SHA3.state | Prims.Tot | [
"total"
] | [] | [
"Spec.SHA3.state",
"Spec.SHA3.index",
"Lib.LoopCombinators.repeati",
"Spec.SHA3.state_chi_inner0"
] | [] | false | false | false | true | false | let state_chi_inner1 (s_pi_rho: state) (y: index) (s: state) : Tot state =
| repeati 5 (state_chi_inner0 s_pi_rho y) s | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.weaken_owriter | val weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': owriter s h1 sout pout_from1 {owvalue w' == owvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) | val weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': owriter s h1 sout pout_from1 {owvalue w' == owvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) | let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 46,
"end_line": 579,
"start_col": 0,
"start_line": 565
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
w: LowParse.Low.Writers.owriter s h0 sout pout_from0 ->
h1: FStar.Monotonic.HyperStack.mem ->
pout_from1: FStar.UInt32.t
-> Prims.Pure
(w':
LowParse.Low.Writers.owriter s h1 sout pout_from1
{LowParse.Low.Writers.owvalue w' == LowParse.Low.Writers.owvalue w}) | Prims.Pure | [] | [] | [
"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.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.owriter",
"LowParse.Low.Writers.OWriter",
"LowParse.Low.Writers.__proj__OWriter__item__v",
"LowParse.Low.Writers.__proj__OWriter__item__w",
"LowParse.Low.Writers.owvalue",
"Prims.l_and",
"LowStar.Monotonic.Buffer.modifies",
"LowParse.Slice.loc_slice_from",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.l_True"
] | [] | false | false | false | false | false | let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': owriter s h1 sout pout_from1 {owvalue w' == owvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) =
| OWriter w.v (fun pout_from -> w.w pout_from) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.greader_tot | val greader_tot
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(#t: Type)
(x: t)
: Tot (r: greader h0 sout pout_from0 t {grvalue r == x}) | val greader_tot
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(#t: Type)
(x: t)
: Tot (r: greader h0 sout pout_from0 t {grvalue r == x}) | let greader_tot
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(#t: Type)
(x: t)
: Tot (r: greader h0 sout pout_from0 t { grvalue r == x } )
= GReader (Ghost.hide x) (fun _ -> x) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 37,
"end_line": 1060,
"start_col": 0,
"start_line": 1053
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f ()
inline_for_extraction
noextract
let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : swriter s h0 space_beyond sout pout_from0 { swvalue w' == swvalue (w (grvalue r)) } )
= SWriter (Ghost.hide (swvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
swrite (w v) pout_from
)
inline_for_extraction
noextract
let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (writer s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : writer s h0 sout pout_from0 { wvalue w' == wvalue (w (grvalue r)) } )
= Writer (Ghost.hide (wvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
write (w v) pout_from
)
inline_for_extraction
noextract
let owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (owriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : owriter s h0 sout pout_from0 { owvalue w' == owvalue (w (grvalue r))})
= OWriter (Ghost.hide (owvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
owrite (w v) pout_from
)
inline_for_extraction
noextract
let lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (lwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : lwriter s h0 sout pout_from0 { lwvalue w' == lwvalue (w (grvalue r)) } )
= LWriter (Ghost.hide (lwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
lwrite (w v) pout_from
)
inline_for_extraction
noextract
let olwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (olwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Pure (olwriter s h0 sout pout_from0)
(requires True)
(ensures (fun w' -> olwvalue w' == olwvalue (w (grvalue r))))
= OLWriter (Ghost.hide (olwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
olwrite (w v) pout_from
)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
h0: FStar.Monotonic.HyperStack.mem ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
pout_from0: FStar.UInt32.t ->
x: t
-> r: LowParse.Low.Writers.greader h0 sout pout_from0 t {LowParse.Low.Writers.grvalue r == x} | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.GReader",
"FStar.Ghost.hide",
"Prims.unit",
"LowParse.Low.Writers.greader",
"Prims.eq2",
"LowParse.Low.Writers.grvalue"
] | [] | false | false | false | false | false | let greader_tot
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(#t: Type)
(x: t)
: Tot (r: greader h0 sout pout_from0 t {grvalue r == x}) =
| GReader (Ghost.hide x) (fun _ -> x) | false |
Spec.SHA3.fst | Spec.SHA3.absorb_inner | val absorb_inner
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block: lbytes rateInBytes)
(s: state)
: Tot state | val absorb_inner
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block: lbytes rateInBytes)
(s: state)
: Tot state | let absorb_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block:lbytes rateInBytes)
(s:state) :
Tot state =
let s = loadState rateInBytes block s in
state_permute s | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 17,
"end_line": 145,
"start_col": 0,
"start_line": 138
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s
let storeState_inner (s:state) (j:size_nat{j < 25}) (block:lbytes 200) : Tot (lbytes 200) =
update_sub block (j * 8) 8 (uint_to_bytes_le #U64 s.[j])
let storeState (rateInBytes:size_nat{rateInBytes <= 200}) (s:state) : Tot (lbytes rateInBytes) =
let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes
let absorb_next (s:state) (rateInBytes:size_nat{rateInBytes > 0 /\ rateInBytes <= 200}) : Tot state =
let nextBlock = create rateInBytes (u8 0) in
let nextBlock = nextBlock.[rateInBytes - 1] <- u8 0x80 in
let s = loadState rateInBytes nextBlock s in
state_permute s
val absorb_last:
delimitedSuffix:byte_t
-> rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200}
-> rem:size_nat{rem < rateInBytes}
-> input:lbytes rem
-> s:state ->
Tot state
let absorb_last delimitedSuffix rateInBytes rem input s =
let lastBlock = create rateInBytes (u8 0) in
let lastBlock = update_sub lastBlock 0 rem input in
let lastBlock = lastBlock.[rem] <- byte_to_uint8 delimitedSuffix in
let s = loadState rateInBytes lastBlock s in
let s =
if not ((delimitedSuffix &. byte 0x80) =. byte 0) &&
(rem = rateInBytes - 1)
then state_permute s else s in
absorb_next s rateInBytes | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false |
rateInBytes: Lib.IntTypes.size_nat{0 < rateInBytes /\ rateInBytes <= 200} ->
block: Lib.ByteSequence.lbytes rateInBytes ->
s: Spec.SHA3.state
-> Spec.SHA3.state | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"Lib.ByteSequence.lbytes",
"Spec.SHA3.state",
"Spec.SHA3.state_permute",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA3.loadState"
] | [] | false | false | false | false | false | let absorb_inner
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block: lbytes rateInBytes)
(s: state)
: Tot state =
| let s = loadState rateInBytes block s in
state_permute s | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.owrite_leaf_cs | val owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s:
serializer p
{ k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 })
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 {owvalue y == Some x}) | val owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s:
serializer p
{ k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 })
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 {owvalue y == Some x}) | let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 630,
"start_col": 0,
"start_line": 614
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
w: LowParse.Low.Base.leaf_writer_strong s ->
h0: FStar.Monotonic.HyperStack.mem ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
pout_from0: FStar.UInt32.t ->
x: t
-> y:
LowParse.Low.Writers.owriter s h0 sout pout_from0
{LowParse.Low.Writers.owvalue y == FStar.Pervasives.Native.Some x} | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.nat",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"Prims.b2t",
"Prims.op_LessThan",
"LowParse.Low.Base.leaf_writer_strong",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.OWriter",
"FStar.Ghost.hide",
"FStar.UInt32.gt",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.sub",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Low.ErrorCode.max_uint32",
"Prims.bool",
"LowParse.Low.Writers.owriter",
"LowParse.Low.Writers.owvalue"
] | [] | false | false | false | false | false | let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s:
serializer p
{ k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 })
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 {owvalue y == Some x}) =
| OWriter (Ghost.hide (Some x))
(fun pout_from ->
if (U32.uint_to_t k.parser_kind_low) `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from) | false |
Spec.SHA3.fst | Spec.SHA3.state_theta_inner_C | val state_theta_inner_C (s: state) (i: size_nat{i < 5}) (_C: lseq uint64 5) : Tot (lseq uint64 5) | val state_theta_inner_C (s: state) (i: size_nat{i < 5}) (_C: lseq uint64 5) : Tot (lseq uint64 5) | let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4 | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 73,
"end_line": 29,
"start_col": 0,
"start_line": 28
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false | s: Spec.SHA3.state -> i: Lib.IntTypes.size_nat{i < 5} -> _C: Lib.Sequence.lseq Lib.IntTypes.uint64 5
-> Lib.Sequence.lseq Lib.IntTypes.uint64 5 | Prims.Tot | [
"total"
] | [] | [
"Spec.SHA3.state",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Lib.Sequence.op_String_Assignment",
"Lib.IntTypes.op_Hat_Dot",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA3.get"
] | [] | false | false | false | false | false | let state_theta_inner_C (s: state) (i: size_nat{i < 5}) (_C: lseq uint64 5) : Tot (lseq uint64 5) =
| _C.[ i ] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4 | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.olwriter_ifthenelse | val olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot
(x:
olwriter s h0 sout pout_from0
{olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ()))}) | val olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot
(x:
olwriter s h0 sout pout_from0
{olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ()))}) | let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 97,
"end_line": 838,
"start_col": 0,
"start_line": 825
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
cond: Prims.bool ->
wtrue: (_: Prims.squash (cond == true) -> LowParse.Low.Writers.olwriter s h0 sout pout_from0) ->
wfalse: (_: Prims.squash (cond == false) -> LowParse.Low.Writers.olwriter s h0 sout pout_from0)
-> x:
LowParse.Low.Writers.olwriter s h0 sout pout_from0
{ LowParse.Low.Writers.olwvalue x ==
(match cond with
| true -> LowParse.Low.Writers.olwvalue (wtrue ())
| _ -> LowParse.Low.Writers.olwvalue (wfalse ())) } | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"Prims.bool",
"Prims.squash",
"LowParse.Low.Writers.olwriter",
"LowParse.Low.Writers.OLWriter",
"LowParse.Low.Writers.__proj__OLWriter__item__v",
"FStar.Ghost.erased",
"Prims.list",
"LowParse.Low.Writers.olwrite",
"LowParse.Low.Writers.olwvalue"
] | [] | false | false | false | false | false | let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot
(x:
olwriter s h0 sout pout_from0
{olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ()))}) =
| OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.owbind | val owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (owriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': owriter s h0 sout pout_from0 {owvalue w' == owvalue (w (grvalue r))}) | val owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (owriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': owriter s h0 sout pout_from0 {owvalue w' == owvalue (w (grvalue r))}) | let owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (owriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : owriter s h0 sout pout_from0 { owvalue w' == owvalue (w (grvalue r))})
= OWriter (Ghost.hide (owvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
owrite (w v) pout_from
) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 1009,
"start_col": 0,
"start_line": 994
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f ()
inline_for_extraction
noextract
let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : swriter s h0 space_beyond sout pout_from0 { swvalue w' == swvalue (w (grvalue r)) } )
= SWriter (Ghost.hide (swvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
swrite (w v) pout_from
)
inline_for_extraction
noextract
let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (writer s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : writer s h0 sout pout_from0 { wvalue w' == wvalue (w (grvalue r)) } )
= Writer (Ghost.hide (wvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
write (w v) pout_from
)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: LowParse.Low.Writers.greader h0 sout pout_from0 tr ->
w: (x: tr -> Prims.Pure (LowParse.Low.Writers.owriter s h0 sout pout_from0))
-> w':
LowParse.Low.Writers.owriter s h0 sout pout_from0
{ LowParse.Low.Writers.owvalue w' ==
LowParse.Low.Writers.owvalue (w (LowParse.Low.Writers.grvalue r)) } | Prims.Tot | [
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.greader",
"LowParse.Low.Writers.owriter",
"LowParse.Low.Writers.grvalue",
"Prims.l_True",
"LowParse.Low.Writers.OWriter",
"FStar.Ghost.hide",
"LowParse.Low.Writers.owvalue",
"LowParse.Low.Writers.owrite",
"LowParse.Low.Writers.gread"
] | [] | false | false | false | false | false | let owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (owriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': owriter s h0 sout pout_from0 {owvalue w' == owvalue (w (grvalue r))}) =
| OWriter (Ghost.hide (owvalue (w (grvalue r))))
(fun pout_from ->
let v = gread r in
owrite (w v) pout_from) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.swbind | val swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (swriter s h0 space_beyond sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': swriter s h0 space_beyond sout pout_from0 {swvalue w' == swvalue (w (grvalue r))}) | val swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (swriter s h0 space_beyond sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': swriter s h0 space_beyond sout pout_from0 {swvalue w' == swvalue (w (grvalue r))}) | let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : swriter s h0 space_beyond sout pout_from0 { swvalue w' == swvalue (w (grvalue r)) } )
= SWriter (Ghost.hide (swvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
swrite (w v) pout_from
) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 971,
"start_col": 0,
"start_line": 955
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f ()
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: LowParse.Low.Writers.greader h0 sout pout_from0 tr ->
w: (x: tr -> Prims.Pure (LowParse.Low.Writers.swriter s h0 space_beyond sout pout_from0))
-> w':
LowParse.Low.Writers.swriter s h0 space_beyond sout pout_from0
{ LowParse.Low.Writers.swvalue w' ==
LowParse.Low.Writers.swvalue (w (LowParse.Low.Writers.grvalue r)) } | Prims.Tot | [
"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",
"FStar.Monotonic.HyperStack.mem",
"Prims.nat",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.greader",
"LowParse.Low.Writers.swriter",
"LowParse.Low.Writers.grvalue",
"Prims.l_True",
"LowParse.Low.Writers.SWriter",
"FStar.Ghost.hide",
"LowParse.Low.Writers.swvalue",
"LowParse.Low.Writers.swrite",
"LowParse.Low.Writers.gread"
] | [] | false | false | false | false | false | let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (swriter s h0 space_beyond sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': swriter s h0 space_beyond sout pout_from0 {swvalue w' == swvalue (w (grvalue r))}) =
| SWriter (Ghost.hide (swvalue (w (grvalue r))))
(fun pout_from ->
let v = gread r in
swrite (w v) pout_from) | false |
Spec.SHA3.fst | Spec.SHA3.state_iota | val state_iota (s: state) (round: size_nat{round < 24}) : Tot state | val state_iota (s: state) (round: size_nat{round < 24}) : Tot state | let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round]) | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 53,
"end_line": 80,
"start_col": 0,
"start_line": 79
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false | s: Spec.SHA3.state -> round: Lib.IntTypes.size_nat{round < 24} -> Spec.SHA3.state | Prims.Tot | [
"total"
] | [] | [
"Spec.SHA3.state",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThan",
"Spec.SHA3.set",
"Lib.IntTypes.op_Hat_Dot",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA3.get",
"Lib.IntTypes.secret",
"Lib.Sequence.op_String_Access",
"Lib.IntTypes.int_t",
"Lib.IntTypes.PUB",
"Spec.SHA3.Constants.keccak_rndc"
] | [] | false | false | false | false | false | let state_iota (s: state) (round: size_nat{round < 24}) : Tot state =
| set s 0 0 (get s 0 0 ^. secret keccak_rndc.[ round ]) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.olwriter_of_lwriter | val olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0) | val olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0) | let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 80,
"end_line": 852,
"start_col": 0,
"start_line": 842
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | w: LowParse.Low.Writers.lwriter s h0 sout pout_from0
-> LowParse.Low.Writers.olwriter s h0 sout pout_from0 | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.lwriter",
"LowParse.Low.Writers.OLWriter",
"FStar.Ghost.hide",
"Prims.list",
"LowParse.Low.Writers.lwvalue",
"LowParse.Low.Writers.lwrite",
"LowParse.Low.Writers.olwriter"
] | [] | false | false | false | false | false | let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0) =
| OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from) | false |
Spec.SHA3.fst | Spec.SHA3.state_theta | val state_theta (s: state) : Tot state | val state_theta (s: state) : Tot state | let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 19,
"end_line": 47,
"start_col": 0,
"start_line": 44
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false | s: Spec.SHA3.state -> Spec.SHA3.state | Prims.Tot | [
"total"
] | [] | [
"Spec.SHA3.state",
"Spec.SHA3.state_theta1",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA3.state_theta0",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.Sequence.index",
"Lib.Sequence.create",
"Lib.IntTypes.uint64",
"Lib.IntTypes.u64"
] | [] | false | false | false | true | false | let state_theta (s: state) : Tot state =
| let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C | false |
Vale.AES.X64.AESopt.fst | Vale.AES.X64.AESopt.va_lemma_untransformedoriginal_Loop6x_partial | val va_lemma_untransformedoriginal_Loop6x_partial : va_b0:va_code -> va_s0:va_state ->
alg:algorithm -> h_LE:quad32 -> y_prev:quad32 -> data:(seq quad32) -> count:nat -> in0_count:nat
-> iv_b:buffer128 -> in0_b:buffer128 -> in_b:buffer128 -> scratch_b:buffer128 -> key_words:(seq
nat32) -> round_keys:(seq quad32) -> keys_b:buffer128 -> hkeys_b:buffer128 -> ctr_BE:quad32
-> Ghost (va_state & va_fuel & quad32_6)
(requires (va_require_total va_b0 (va_code_untransformedoriginal_Loop6x_partial alg) va_s0 /\
va_get_ok va_s0 /\ (let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in let (prev:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (Vale.Def.Types_s.reverse_bytes_quad32 y_prev) in sse_enabled
/\ movbe_enabled /\ va_get_xmm 2 va_s0 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0
16777216 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 2 va_s0) (va_get_reg64 rR8
va_s0) iv_b 1 (va_get_mem_layout va_s0) Public /\ Vale.X64.Decls.validSrcAddrsOffset128
(va_get_mem_heaplet 6 va_s0) (va_get_reg64 rR14 va_s0) in0_b (in0_count `op_Multiply` 6) 6
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrsOffset128 (va_get_mem_heaplet 6
va_s0) (va_get_reg64 rRdi va_s0) in_b (count `op_Multiply` 6) 6 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 3 va_s0) (va_get_reg64 rRbp
va_s0) scratch_b 9 (va_get_mem_layout va_s0) Secret /\ va_get_reg64 rRdi va_s0 + 96 < pow2_64
/\ aes_reqs_offset alg key_words round_keys keys_b (va_get_reg64 rRcx va_s0)
(va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0) /\ va_get_xmm 15 va_s0 ==
FStar.Seq.Base.index #quad32 round_keys 0 /\ va_get_xmm 2 va_s0 == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 0 0 0 16777216 /\ va_get_xmm 1 va_s0 ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 0) /\ va_get_reg64 rRbx
va_s0 == Vale.Def.Words_s.__proj__Mkfour__item__lo0 ctr_BE `op_Modulus` 256 /\ va_get_xmm 9
va_s0 == Vale.Def.Types_s.quad32_xor (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.AES.GCTR.inc32lite ctr_BE 0)) (va_get_xmm 15 va_s0) /\ (va_get_reg64 rRbx va_s0 + 6 < 256
==> (va_get_xmm 9 va_s0, va_get_xmm 10 va_s0, va_get_xmm 11 va_s0, va_get_xmm 12 va_s0,
va_get_xmm 13 va_s0, va_get_xmm 14 va_s0) == xor_reverse_inc32lite_6 1 0 ctr_BE (va_get_xmm 15
va_s0)) /\ FStar.Seq.Base.length #quad32 data == 6 /\ hkeys_b_powers hkeys_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0) (va_get_reg64 rR9 va_s0 - 32) h /\
scratch_b_data true true scratch_b 8 5 (va_get_mem_heaplet 3 va_s0) (va_get_mem_layout va_s0)
(va_get_reg64 rRbp va_s0) data /\ va_get_xmm 7 va_s0 == Vale.Def.Types_s.reverse_bytes_quad32
(va_subscript_FStar__Seq__Base__seq data 5) /\ add (add (Vale.Math.Poly2.Bits_s.of_quad32
(va_get_xmm 8 va_s0)) (Vale.Math.Poly2.Bits_s.of_quad32 (va_get_xmm 4 va_s0)))
(Vale.Math.Poly2.Bits_s.of_quad32 (Vale.X64.Decls.buffer128_read scratch_b 1
(va_get_mem_heaplet 3 va_s0))) == prev)))
(ensures (fun (va_sM, va_fM, init) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM
/\ (let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in let (prev:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (Vale.Def.Types_s.reverse_bytes_quad32 y_prev) in
Vale.X64.Decls.modifies_buffer_specific128 scratch_b (va_get_mem_heaplet 3 va_s0)
(va_get_mem_heaplet 3 va_sM) 1 8 /\ Vale.X64.Decls.modifies_buffer_specific128 iv_b
(va_get_mem_heaplet 2 va_s0) (va_get_mem_heaplet 2 va_sM) 0 0 /\ (0 <= va_get_reg64 rRbx va_sM
/\ va_get_reg64 rRbx va_sM < 256) /\ va_get_reg64 rRbx va_sM ==
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (Vale.AES.GCTR.inc32lite ctr_BE 6) `op_Modulus` 256
/\ (va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM,
va_get_xmm 13 va_sM, va_get_xmm 14 va_sM) == rounds_opaque_6 init round_keys
(Vale.AES.AES_common_s.nr alg - 1) /\ va_get_reg64 rR13 va_sM ==
Vale.Def.Types_s.reverse_bytes_nat64 (Vale.Arch.Types.hi64 (Vale.X64.Decls.buffer128_read in0_b
(in0_count `op_Multiply` 6 + 0) (va_get_mem_heaplet 6 va_sM))) /\ va_get_reg64 rR12 va_sM ==
Vale.Def.Types_s.reverse_bytes_nat64 (Vale.Arch.Types.lo64 (Vale.X64.Decls.buffer128_read in0_b
(in0_count `op_Multiply` 6 + 0) (va_get_mem_heaplet 6 va_sM))) /\ (let rk =
FStar.Seq.Base.index #quad32 round_keys (Vale.AES.AES_common_s.nr alg) in (va_get_xmm 2 va_sM,
va_get_xmm 0 va_sM, va_get_xmm 5 va_sM, va_get_xmm 6 va_sM, va_get_xmm 7 va_sM, va_get_xmm 3
va_sM) == make_six_of #quad32 (fun (i:(va_int_range 0 5)) -> Vale.Def.Types_s.quad32_xor rk
(Vale.X64.Decls.buffer128_read in_b (count `op_Multiply` 6 + i) (va_get_mem_heaplet 6 va_sM)))
/\ Vale.X64.Decls.buffer128_read scratch_b 8 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 6) /\
Vale.X64.Decls.buffer128_read scratch_b 2 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b (in0_count
`op_Multiply` 6 + 5) (va_get_mem_heaplet 6 va_s0)) /\ Vale.X64.Decls.buffer128_read scratch_b 3
(va_get_mem_heaplet 3 va_sM) == Vale.Def.Types_s.reverse_bytes_quad32
(Vale.X64.Decls.buffer128_read in0_b (in0_count `op_Multiply` 6 + 4) (va_get_mem_heaplet 6
va_s0)) /\ Vale.X64.Decls.buffer128_read scratch_b 4 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b (in0_count
`op_Multiply` 6 + 3) (va_get_mem_heaplet 6 va_s0)) /\ Vale.X64.Decls.buffer128_read scratch_b 5
(va_get_mem_heaplet 3 va_sM) == Vale.Def.Types_s.reverse_bytes_quad32
(Vale.X64.Decls.buffer128_read in0_b (in0_count `op_Multiply` 6 + 2) (va_get_mem_heaplet 6
va_s0)) /\ Vale.X64.Decls.buffer128_read scratch_b 6 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b (in0_count
`op_Multiply` 6 + 1) (va_get_mem_heaplet 6 va_s0)) /\ init == make_six_of #quad32 (fun
(n:(va_int_range 0 5)) -> Vale.Def.Types_s.quad32_xor (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.AES.GCTR.inc32lite ctr_BE n)) (FStar.Seq.Base.index #Vale.Def.Types_s.quad32 round_keys
0)) /\ (let eventual_Xi = add (add (Vale.Math.Poly2.Bits_s.of_quad32 (va_get_xmm 8 va_sM))
(Vale.Math.Poly2.Bits_s.of_quad32 (Vale.X64.Decls.buffer128_read scratch_b 1
(va_get_mem_heaplet 3 va_sM)))) (Vale.Math.Poly2.Bits_s.of_quad32 (va_get_xmm 4 va_sM)) in
eventual_Xi == Vale.Math.Poly2.Bits_s.of_quad32 (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.AES.GHash.ghash_incremental h_LE y_prev data))))) /\ va_state_eq va_sM (va_update_flags
va_sM (va_update_mem_heaplet 3 va_sM (va_update_mem_heaplet 2 va_sM (va_update_xmm 15 va_sM
(va_update_xmm 14 va_sM (va_update_xmm 13 va_sM (va_update_xmm 12 va_sM (va_update_xmm 11 va_sM
(va_update_xmm 10 va_sM (va_update_xmm 9 va_sM (va_update_xmm 8 va_sM (va_update_xmm 7 va_sM
(va_update_xmm 6 va_sM (va_update_xmm 5 va_sM (va_update_xmm 4 va_sM (va_update_xmm 3 va_sM
(va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_xmm 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rR12 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rRbx va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))))))) | val va_lemma_untransformedoriginal_Loop6x_partial : va_b0:va_code -> va_s0:va_state ->
alg:algorithm -> h_LE:quad32 -> y_prev:quad32 -> data:(seq quad32) -> count:nat -> in0_count:nat
-> iv_b:buffer128 -> in0_b:buffer128 -> in_b:buffer128 -> scratch_b:buffer128 -> key_words:(seq
nat32) -> round_keys:(seq quad32) -> keys_b:buffer128 -> hkeys_b:buffer128 -> ctr_BE:quad32
-> Ghost (va_state & va_fuel & quad32_6)
(requires (va_require_total va_b0 (va_code_untransformedoriginal_Loop6x_partial alg) va_s0 /\
va_get_ok va_s0 /\ (let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in let (prev:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (Vale.Def.Types_s.reverse_bytes_quad32 y_prev) in sse_enabled
/\ movbe_enabled /\ va_get_xmm 2 va_s0 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0
16777216 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 2 va_s0) (va_get_reg64 rR8
va_s0) iv_b 1 (va_get_mem_layout va_s0) Public /\ Vale.X64.Decls.validSrcAddrsOffset128
(va_get_mem_heaplet 6 va_s0) (va_get_reg64 rR14 va_s0) in0_b (in0_count `op_Multiply` 6) 6
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrsOffset128 (va_get_mem_heaplet 6
va_s0) (va_get_reg64 rRdi va_s0) in_b (count `op_Multiply` 6) 6 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 3 va_s0) (va_get_reg64 rRbp
va_s0) scratch_b 9 (va_get_mem_layout va_s0) Secret /\ va_get_reg64 rRdi va_s0 + 96 < pow2_64
/\ aes_reqs_offset alg key_words round_keys keys_b (va_get_reg64 rRcx va_s0)
(va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0) /\ va_get_xmm 15 va_s0 ==
FStar.Seq.Base.index #quad32 round_keys 0 /\ va_get_xmm 2 va_s0 == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 0 0 0 16777216 /\ va_get_xmm 1 va_s0 ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 0) /\ va_get_reg64 rRbx
va_s0 == Vale.Def.Words_s.__proj__Mkfour__item__lo0 ctr_BE `op_Modulus` 256 /\ va_get_xmm 9
va_s0 == Vale.Def.Types_s.quad32_xor (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.AES.GCTR.inc32lite ctr_BE 0)) (va_get_xmm 15 va_s0) /\ (va_get_reg64 rRbx va_s0 + 6 < 256
==> (va_get_xmm 9 va_s0, va_get_xmm 10 va_s0, va_get_xmm 11 va_s0, va_get_xmm 12 va_s0,
va_get_xmm 13 va_s0, va_get_xmm 14 va_s0) == xor_reverse_inc32lite_6 1 0 ctr_BE (va_get_xmm 15
va_s0)) /\ FStar.Seq.Base.length #quad32 data == 6 /\ hkeys_b_powers hkeys_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0) (va_get_reg64 rR9 va_s0 - 32) h /\
scratch_b_data true true scratch_b 8 5 (va_get_mem_heaplet 3 va_s0) (va_get_mem_layout va_s0)
(va_get_reg64 rRbp va_s0) data /\ va_get_xmm 7 va_s0 == Vale.Def.Types_s.reverse_bytes_quad32
(va_subscript_FStar__Seq__Base__seq data 5) /\ add (add (Vale.Math.Poly2.Bits_s.of_quad32
(va_get_xmm 8 va_s0)) (Vale.Math.Poly2.Bits_s.of_quad32 (va_get_xmm 4 va_s0)))
(Vale.Math.Poly2.Bits_s.of_quad32 (Vale.X64.Decls.buffer128_read scratch_b 1
(va_get_mem_heaplet 3 va_s0))) == prev)))
(ensures (fun (va_sM, va_fM, init) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM
/\ (let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in let (prev:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (Vale.Def.Types_s.reverse_bytes_quad32 y_prev) in
Vale.X64.Decls.modifies_buffer_specific128 scratch_b (va_get_mem_heaplet 3 va_s0)
(va_get_mem_heaplet 3 va_sM) 1 8 /\ Vale.X64.Decls.modifies_buffer_specific128 iv_b
(va_get_mem_heaplet 2 va_s0) (va_get_mem_heaplet 2 va_sM) 0 0 /\ (0 <= va_get_reg64 rRbx va_sM
/\ va_get_reg64 rRbx va_sM < 256) /\ va_get_reg64 rRbx va_sM ==
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (Vale.AES.GCTR.inc32lite ctr_BE 6) `op_Modulus` 256
/\ (va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM,
va_get_xmm 13 va_sM, va_get_xmm 14 va_sM) == rounds_opaque_6 init round_keys
(Vale.AES.AES_common_s.nr alg - 1) /\ va_get_reg64 rR13 va_sM ==
Vale.Def.Types_s.reverse_bytes_nat64 (Vale.Arch.Types.hi64 (Vale.X64.Decls.buffer128_read in0_b
(in0_count `op_Multiply` 6 + 0) (va_get_mem_heaplet 6 va_sM))) /\ va_get_reg64 rR12 va_sM ==
Vale.Def.Types_s.reverse_bytes_nat64 (Vale.Arch.Types.lo64 (Vale.X64.Decls.buffer128_read in0_b
(in0_count `op_Multiply` 6 + 0) (va_get_mem_heaplet 6 va_sM))) /\ (let rk =
FStar.Seq.Base.index #quad32 round_keys (Vale.AES.AES_common_s.nr alg) in (va_get_xmm 2 va_sM,
va_get_xmm 0 va_sM, va_get_xmm 5 va_sM, va_get_xmm 6 va_sM, va_get_xmm 7 va_sM, va_get_xmm 3
va_sM) == make_six_of #quad32 (fun (i:(va_int_range 0 5)) -> Vale.Def.Types_s.quad32_xor rk
(Vale.X64.Decls.buffer128_read in_b (count `op_Multiply` 6 + i) (va_get_mem_heaplet 6 va_sM)))
/\ Vale.X64.Decls.buffer128_read scratch_b 8 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 6) /\
Vale.X64.Decls.buffer128_read scratch_b 2 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b (in0_count
`op_Multiply` 6 + 5) (va_get_mem_heaplet 6 va_s0)) /\ Vale.X64.Decls.buffer128_read scratch_b 3
(va_get_mem_heaplet 3 va_sM) == Vale.Def.Types_s.reverse_bytes_quad32
(Vale.X64.Decls.buffer128_read in0_b (in0_count `op_Multiply` 6 + 4) (va_get_mem_heaplet 6
va_s0)) /\ Vale.X64.Decls.buffer128_read scratch_b 4 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b (in0_count
`op_Multiply` 6 + 3) (va_get_mem_heaplet 6 va_s0)) /\ Vale.X64.Decls.buffer128_read scratch_b 5
(va_get_mem_heaplet 3 va_sM) == Vale.Def.Types_s.reverse_bytes_quad32
(Vale.X64.Decls.buffer128_read in0_b (in0_count `op_Multiply` 6 + 2) (va_get_mem_heaplet 6
va_s0)) /\ Vale.X64.Decls.buffer128_read scratch_b 6 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b (in0_count
`op_Multiply` 6 + 1) (va_get_mem_heaplet 6 va_s0)) /\ init == make_six_of #quad32 (fun
(n:(va_int_range 0 5)) -> Vale.Def.Types_s.quad32_xor (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.AES.GCTR.inc32lite ctr_BE n)) (FStar.Seq.Base.index #Vale.Def.Types_s.quad32 round_keys
0)) /\ (let eventual_Xi = add (add (Vale.Math.Poly2.Bits_s.of_quad32 (va_get_xmm 8 va_sM))
(Vale.Math.Poly2.Bits_s.of_quad32 (Vale.X64.Decls.buffer128_read scratch_b 1
(va_get_mem_heaplet 3 va_sM)))) (Vale.Math.Poly2.Bits_s.of_quad32 (va_get_xmm 4 va_sM)) in
eventual_Xi == Vale.Math.Poly2.Bits_s.of_quad32 (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.AES.GHash.ghash_incremental h_LE y_prev data))))) /\ va_state_eq va_sM (va_update_flags
va_sM (va_update_mem_heaplet 3 va_sM (va_update_mem_heaplet 2 va_sM (va_update_xmm 15 va_sM
(va_update_xmm 14 va_sM (va_update_xmm 13 va_sM (va_update_xmm 12 va_sM (va_update_xmm 11 va_sM
(va_update_xmm 10 va_sM (va_update_xmm 9 va_sM (va_update_xmm 8 va_sM (va_update_xmm 7 va_sM
(va_update_xmm 6 va_sM (va_update_xmm 5 va_sM (va_update_xmm 4 va_sM (va_update_xmm 3 va_sM
(va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_xmm 0 va_sM (va_update_reg64 rR13
va_sM (va_update_reg64 rR12 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rRbx va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))))))) | let va_lemma_untransformedoriginal_Loop6x_partial va_b0 va_s0 alg h_LE y_prev data count in0_count
iv_b in0_b in_b scratch_b key_words round_keys keys_b hkeys_b ctr_BE =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_mem_heaplet 3; va_Mod_mem_heaplet 2; va_Mod_xmm
15; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9;
va_Mod_xmm 8; va_Mod_xmm 7; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 4; va_Mod_xmm 3; va_Mod_xmm
2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_reg64 rR11;
va_Mod_reg64 rRbx; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_untransformedoriginal_Loop6x_partial va_mods alg h_LE y_prev data count
in0_count iv_b in0_b in_b scratch_b key_words round_keys keys_b hkeys_b ctr_BE in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_untransformedoriginal_Loop6x_partial
alg) va_qc va_s0 (fun va_s0 va_sM va_g -> let init = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 758 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_ok va_sM) /\ (let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in let (prev:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (Vale.Def.Types_s.reverse_bytes_quad32 y_prev) in label
va_range1
"***** POSTCONDITION NOT MET AT line 837 column 72 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 scratch_b (va_get_mem_heaplet 3 va_s0)
(va_get_mem_heaplet 3 va_sM) 1 8) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 838 column 70 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 iv_b (va_get_mem_heaplet 2 va_s0)
(va_get_mem_heaplet 2 va_sM) 0 0) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 843 column 27 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(0 <= va_get_reg64 rRbx va_sM /\ va_get_reg64 rRbx va_sM < 256) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 844 column 50 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_reg64 rRbx va_sM == Vale.Def.Words_s.__proj__Mkfour__item__lo0 (Vale.AES.GCTR.inc32lite
ctr_BE 6) `op_Modulus` 256) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 847 column 118 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM, va_get_xmm
13 va_sM, va_get_xmm 14 va_sM) == rounds_opaque_6 init round_keys (Vale.AES.AES_common_s.nr alg
- 1)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 848 column 90 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_reg64 rR13 va_sM == Vale.Def.Types_s.reverse_bytes_nat64 (Vale.Arch.Types.hi64
(Vale.X64.Decls.buffer128_read in0_b (in0_count `op_Multiply` 6 + 0) (va_get_mem_heaplet 6
va_sM)))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 849 column 90 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_reg64 rR12 va_sM == Vale.Def.Types_s.reverse_bytes_nat64 (Vale.Arch.Types.lo64
(Vale.X64.Decls.buffer128_read in0_b (in0_count `op_Multiply` 6 + 0) (va_get_mem_heaplet 6
va_sM)))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 850 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(let rk = FStar.Seq.Base.index #quad32 round_keys (Vale.AES.AES_common_s.nr alg) in label
va_range1
"***** POSTCONDITION NOT MET AT line 852 column 107 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((va_get_xmm 2 va_sM, va_get_xmm 0 va_sM, va_get_xmm 5 va_sM, va_get_xmm 6 va_sM, va_get_xmm 7
va_sM, va_get_xmm 3 va_sM) == make_six_of #quad32 (fun (i:(va_int_range 0 5)) ->
Vale.Def.Types_s.quad32_xor rk (Vale.X64.Decls.buffer128_read in_b (count `op_Multiply` 6 + i)
(va_get_mem_heaplet 6 va_sM)))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 853 column 90 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 8 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 6)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 857 column 122 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 2 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b (in0_count
`op_Multiply` 6 + 5) (va_get_mem_heaplet 6 va_s0))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 858 column 122 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 3 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b (in0_count
`op_Multiply` 6 + 4) (va_get_mem_heaplet 6 va_s0))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 859 column 122 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 4 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b (in0_count
`op_Multiply` 6 + 3) (va_get_mem_heaplet 6 va_s0))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 860 column 122 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 5 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b (in0_count
`op_Multiply` 6 + 2) (va_get_mem_heaplet 6 va_s0))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 861 column 122 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 6 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b (in0_count
`op_Multiply` 6 + 1) (va_get_mem_heaplet 6 va_s0))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 863 column 90 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(init == make_six_of #quad32 (fun (n:(va_int_range 0 5)) -> Vale.Def.Types_s.quad32_xor
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE n))
(FStar.Seq.Base.index #Vale.Def.Types_s.quad32 round_keys 0))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 864 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(let eventual_Xi = add (add (Vale.Math.Poly2.Bits_s.of_quad32 (va_get_xmm 8 va_sM))
(Vale.Math.Poly2.Bits_s.of_quad32 (Vale.X64.Decls.buffer128_read scratch_b 1
(va_get_mem_heaplet 3 va_sM)))) (Vale.Math.Poly2.Bits_s.of_quad32 (va_get_xmm 4 va_sM)) in
label va_range1
"***** POSTCONDITION NOT MET AT line 865 column 94 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(eventual_Xi == Vale.Math.Poly2.Bits_s.of_quad32 (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.AES.GHash.ghash_incremental h_LE y_prev data))))))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_mem_heaplet 3; va_Mod_mem_heaplet 2; va_Mod_xmm 15;
va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9;
va_Mod_xmm 8; va_Mod_xmm 7; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 4; va_Mod_xmm 3; va_Mod_xmm
2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_reg64 rR11;
va_Mod_reg64 rRbx; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
let init = va_g in
(va_sM, va_fM, init) | {
"file_name": "obj/Vale.AES.X64.AESopt.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 2164,
"start_col": 0,
"start_line": 2075
} | module Vale.AES.X64.AESopt
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.AES.AES_helpers
//open Vale.Poly1305.Math // For lemma_poly_bits64()
open Vale.AES.GCM_helpers
open Vale.AES.GCTR_s
open Vale.AES.GCTR
open Vale.Arch.TypesNative
open Vale.X64.CPU_Features_s
open Vale.Math.Poly2_s
open Vale.AES.GF128_s
open Vale.AES.GF128
open Vale.AES.GHash
open Vale.AES.X64.PolyOps
open Vale.AES.X64.AESopt2
open Vale.AES.X64.AESGCM_expected_code
open Vale.Transformers.Transform
open FStar.Mul
let add = Vale.Math.Poly2_s.add
#reset-options "--z3rlimit 30"
//-- finish_aes_encrypt_le
val finish_aes_encrypt_le : alg:algorithm -> input_LE:quad32 -> key:(seq nat32)
-> Lemma
(requires (Vale.AES.AES_s.is_aes_key_LE alg key))
(ensures (Vale.AES.AES_s.aes_encrypt_LE alg key input_LE == Vale.AES.AES_s.eval_cipher alg
input_LE (Vale.AES.AES_s.key_to_round_keys_LE alg key)))
let finish_aes_encrypt_le alg input_LE key =
Vale.AES.AES_s.aes_encrypt_LE_reveal ();
Vale.AES.AES_s.eval_cipher_reveal ();
()
//--
//-- Load_two_lsb
[@ "opaque_to_smt"]
let va_code_Load_two_lsb dst =
(va_Block (va_CCons (va_code_ZeroXmm dst) (va_CCons (va_code_PinsrqImm dst 2 0
(va_op_reg_opr64_reg64 rR11)) (va_CNil ()))))
[@ "opaque_to_smt"]
let va_codegen_success_Load_two_lsb dst =
(va_pbool_and (va_codegen_success_ZeroXmm dst) (va_pbool_and (va_codegen_success_PinsrqImm dst 2
0 (va_op_reg_opr64_reg64 rR11)) (va_ttrue ())))
[@"opaque_to_smt"]
let va_lemma_Load_two_lsb va_b0 va_s0 dst =
va_reveal_opaque (`%va_code_Load_two_lsb) (va_code_Load_two_lsb dst);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let (va_s3, va_fc3) = va_lemma_ZeroXmm (va_hd va_b1) va_s0 dst in
let va_b3 = va_tl va_b1 in
Vale.Arch.Types.lemma_insert_nat64_nat32s (va_eval_xmm va_s3 dst) 2 0;
assert (Vale.Arch.Types.two_to_nat32 (Vale.Def.Words_s.Mktwo #Vale.Def.Words_s.nat32 2 0) == 2);
let (va_s6, va_fc6) = va_lemma_PinsrqImm (va_hd va_b3) va_s3 dst 2 0 (va_op_reg_opr64_reg64 rR11)
in
let va_b6 = va_tl va_b3 in
let (va_sM, va_f6) = va_lemma_empty_total va_s6 va_b6 in
let va_f3 = va_lemma_merge_total va_b3 va_s3 va_fc6 va_s6 va_f6 va_sM in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc3 va_s3 va_f3 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Load_two_lsb dst va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Load_two_lsb (va_code_Load_two_lsb dst) va_s0 dst in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_reg64 rR11 va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0)))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_reg64 rR11; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Load_0xc2_msb
val va_code_Load_0xc2_msb : dst:va_operand_xmm -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Load_0xc2_msb dst =
(va_Block (va_CCons (va_code_ZeroXmm dst) (va_CCons (va_code_PinsrqImm dst 13979173243358019584 1
(va_op_reg_opr64_reg64 rR11)) (va_CNil ()))))
val va_codegen_success_Load_0xc2_msb : dst:va_operand_xmm -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Load_0xc2_msb dst =
(va_pbool_and (va_codegen_success_ZeroXmm dst) (va_pbool_and (va_codegen_success_PinsrqImm dst
13979173243358019584 1 (va_op_reg_opr64_reg64 rR11)) (va_ttrue ())))
val va_lemma_Load_0xc2_msb : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load_0xc2_msb dst) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 3254779904 /\
va_state_eq va_sM (va_update_flags va_sM (va_update_reg64 rR11 va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0))))))
[@"opaque_to_smt"]
let va_lemma_Load_0xc2_msb va_b0 va_s0 dst =
va_reveal_opaque (`%va_code_Load_0xc2_msb) (va_code_Load_0xc2_msb dst);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let (va_s3, va_fc3) = va_lemma_ZeroXmm (va_hd va_b1) va_s0 dst in
let va_b3 = va_tl va_b1 in
assert (Vale.Arch.Types.two_to_nat32 (Vale.Def.Words_s.Mktwo #Vale.Def.Words_s.nat32 0
3254779904) == 13979173243358019584);
Vale.Arch.Types.lemma_insert_nat64_nat32s (va_eval_xmm va_s3 dst) 0 3254779904;
let (va_s6, va_fc6) = va_lemma_PinsrqImm (va_hd va_b3) va_s3 dst 13979173243358019584 1
(va_op_reg_opr64_reg64 rR11) in
let va_b6 = va_tl va_b3 in
let (va_sM, va_f6) = va_lemma_empty_total va_s6 va_b6 in
let va_f3 = va_lemma_merge_total va_b3 va_s3 va_fc6 va_s6 va_f6 va_sM in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc3 va_s3 va_f3 va_sM in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Load_0xc2_msb (dst:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) :
Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall (va_x_dst:va_value_xmm)
(va_x_r11:nat64) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_reg64
rR11 va_x_r11 (va_upd_operand_xmm dst va_x_dst va_s0)) in va_get_ok va_sM /\ va_eval_xmm va_sM
dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 3254779904 ==> va_k va_sM (())))
val va_wpProof_Load_0xc2_msb : dst:va_operand_xmm -> va_s0:va_state -> va_k:(va_state -> unit ->
Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load_0xc2_msb dst va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Load_0xc2_msb dst) ([va_Mod_flags;
va_Mod_reg64 rR11; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Load_0xc2_msb dst va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Load_0xc2_msb (va_code_Load_0xc2_msb dst) va_s0 dst in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_reg64 rR11 va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0)))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_reg64 rR11; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Load_0xc2_msb (dst:va_operand_xmm) : (va_quickCode unit (va_code_Load_0xc2_msb dst)) =
(va_QProc (va_code_Load_0xc2_msb dst) ([va_Mod_flags; va_Mod_reg64 rR11; va_mod_xmm dst])
(va_wp_Load_0xc2_msb dst) (va_wpProof_Load_0xc2_msb dst))
//--
//-- Load_one_lsb
[@ "opaque_to_smt"]
let va_code_Load_one_lsb dst =
(va_Block (va_CCons (va_code_ZeroXmm dst) (va_CCons (va_code_PinsrqImm dst 1 0
(va_op_reg_opr64_reg64 rR11)) (va_CNil ()))))
[@ "opaque_to_smt"]
let va_codegen_success_Load_one_lsb dst =
(va_pbool_and (va_codegen_success_ZeroXmm dst) (va_pbool_and (va_codegen_success_PinsrqImm dst 1
0 (va_op_reg_opr64_reg64 rR11)) (va_ttrue ())))
[@"opaque_to_smt"]
let va_lemma_Load_one_lsb va_b0 va_s0 dst =
va_reveal_opaque (`%va_code_Load_one_lsb) (va_code_Load_one_lsb dst);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let (va_s3, va_fc3) = va_lemma_ZeroXmm (va_hd va_b1) va_s0 dst in
let va_b3 = va_tl va_b1 in
Vale.Arch.Types.lemma_insert_nat64_nat32s (va_eval_xmm va_s3 dst) 1 0;
assert (Vale.Arch.Types.two_to_nat32 (Vale.Def.Words_s.Mktwo #Vale.Def.Words_s.nat32 1 0) == 1);
let (va_s6, va_fc6) = va_lemma_PinsrqImm (va_hd va_b3) va_s3 dst 1 0 (va_op_reg_opr64_reg64 rR11)
in
let va_b6 = va_tl va_b3 in
let (va_sM, va_f6) = va_lemma_empty_total va_s6 va_b6 in
let va_f3 = va_lemma_merge_total va_b3 va_s3 va_fc6 va_s6 va_f6 va_sM in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc3 va_s3 va_f3 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Load_one_lsb dst va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Load_one_lsb (va_code_Load_one_lsb dst) va_s0 dst in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_reg64 rR11 va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0)))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_reg64 rR11; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Handle_ctr32
val va_code_Handle_ctr32 : va_dummy:unit -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_Handle_ctr32 () =
(va_Block (va_CCons (va_code_InitPshufbMask (va_op_xmm_xmm 0) (va_op_reg_opr64_reg64 rR11))
(va_CCons (va_code_VPshufb (va_op_xmm_xmm 6) (va_op_xmm_xmm 1) (va_op_xmm_xmm 0)) (va_CCons
(va_code_Load_one_lsb (va_op_xmm_xmm 5)) (va_CCons (va_code_VPaddd (va_op_xmm_xmm 10)
(va_op_xmm_xmm 6) (va_op_xmm_xmm 5)) (va_CCons (va_code_Load_two_lsb (va_op_xmm_xmm 5))
(va_CCons (va_code_VPaddd (va_op_xmm_xmm 11) (va_op_xmm_xmm 6) (va_op_xmm_xmm 5)) (va_CCons
(va_code_VPaddd (va_op_xmm_xmm 12) (va_op_xmm_xmm 10) (va_op_xmm_xmm 5)) (va_CCons
(va_code_VPshufb (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_xmm_xmm 0)) (va_CCons
(va_code_VPaddd (va_op_xmm_xmm 13) (va_op_xmm_xmm 11) (va_op_xmm_xmm 5)) (va_CCons
(va_code_VPshufb (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_xmm_xmm 0)) (va_CCons
(va_code_VPxor (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_opr128_xmm 15)) (va_CCons
(va_code_VPaddd (va_op_xmm_xmm 14) (va_op_xmm_xmm 12) (va_op_xmm_xmm 5)) (va_CCons
(va_code_VPshufb (va_op_xmm_xmm 12) (va_op_xmm_xmm 12) (va_op_xmm_xmm 0)) (va_CCons
(va_code_VPxor (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_opr128_xmm 15)) (va_CCons
(va_code_VPaddd (va_op_xmm_xmm 1) (va_op_xmm_xmm 13) (va_op_xmm_xmm 5)) (va_CCons
(va_code_VPshufb (va_op_xmm_xmm 13) (va_op_xmm_xmm 13) (va_op_xmm_xmm 0)) (va_CCons
(va_code_VPshufb (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_xmm_xmm 0)) (va_CCons
(va_code_VPshufb (va_op_xmm_xmm 1) (va_op_xmm_xmm 1) (va_op_xmm_xmm 0)) (va_CNil
()))))))))))))))))))))
val va_codegen_success_Handle_ctr32 : va_dummy:unit -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_Handle_ctr32 () =
(va_pbool_and (va_codegen_success_InitPshufbMask (va_op_xmm_xmm 0) (va_op_reg_opr64_reg64 rR11))
(va_pbool_and (va_codegen_success_VPshufb (va_op_xmm_xmm 6) (va_op_xmm_xmm 1) (va_op_xmm_xmm
0)) (va_pbool_and (va_codegen_success_Load_one_lsb (va_op_xmm_xmm 5)) (va_pbool_and
(va_codegen_success_VPaddd (va_op_xmm_xmm 10) (va_op_xmm_xmm 6) (va_op_xmm_xmm 5))
(va_pbool_and (va_codegen_success_Load_two_lsb (va_op_xmm_xmm 5)) (va_pbool_and
(va_codegen_success_VPaddd (va_op_xmm_xmm 11) (va_op_xmm_xmm 6) (va_op_xmm_xmm 5))
(va_pbool_and (va_codegen_success_VPaddd (va_op_xmm_xmm 12) (va_op_xmm_xmm 10) (va_op_xmm_xmm
5)) (va_pbool_and (va_codegen_success_VPshufb (va_op_xmm_xmm 10) (va_op_xmm_xmm 10)
(va_op_xmm_xmm 0)) (va_pbool_and (va_codegen_success_VPaddd (va_op_xmm_xmm 13) (va_op_xmm_xmm
11) (va_op_xmm_xmm 5)) (va_pbool_and (va_codegen_success_VPshufb (va_op_xmm_xmm 11)
(va_op_xmm_xmm 11) (va_op_xmm_xmm 0)) (va_pbool_and (va_codegen_success_VPxor (va_op_xmm_xmm
10) (va_op_xmm_xmm 10) (va_op_opr128_xmm 15)) (va_pbool_and (va_codegen_success_VPaddd
(va_op_xmm_xmm 14) (va_op_xmm_xmm 12) (va_op_xmm_xmm 5)) (va_pbool_and
(va_codegen_success_VPshufb (va_op_xmm_xmm 12) (va_op_xmm_xmm 12) (va_op_xmm_xmm 0))
(va_pbool_and (va_codegen_success_VPxor (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_opr128_xmm
15)) (va_pbool_and (va_codegen_success_VPaddd (va_op_xmm_xmm 1) (va_op_xmm_xmm 13)
(va_op_xmm_xmm 5)) (va_pbool_and (va_codegen_success_VPshufb (va_op_xmm_xmm 13) (va_op_xmm_xmm
13) (va_op_xmm_xmm 0)) (va_pbool_and (va_codegen_success_VPshufb (va_op_xmm_xmm 14)
(va_op_xmm_xmm 14) (va_op_xmm_xmm 0)) (va_pbool_and (va_codegen_success_VPshufb (va_op_xmm_xmm
1) (va_op_xmm_xmm 1) (va_op_xmm_xmm 0)) (va_ttrue ())))))))))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_Handle_ctr32 (va_mods:va_mods_t) (ctr_BE:quad32) : (va_quickCode unit
(va_code_Handle_ctr32 ())) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 256 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_InitPshufbMask (va_op_xmm_xmm 0) (va_op_reg_opr64_reg64 rR11)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 257 column 12 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPshufb (va_op_xmm_xmm 6) (va_op_xmm_xmm 1) (va_op_xmm_xmm 0)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 261 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load_one_lsb (va_op_xmm_xmm 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 262 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 10) (va_op_xmm_xmm 6) (va_op_xmm_xmm 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 263 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load_two_lsb (va_op_xmm_xmm 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 264 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 11) (va_op_xmm_xmm 6) (va_op_xmm_xmm 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 265 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 12) (va_op_xmm_xmm 10) (va_op_xmm_xmm 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 266 column 12 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPshufb (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_xmm_xmm 0)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 267 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 13) (va_op_xmm_xmm 11) (va_op_xmm_xmm 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 268 column 12 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPshufb (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_xmm_xmm 0)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 269 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_opr128_xmm 15)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 270 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 14) (va_op_xmm_xmm 12) (va_op_xmm_xmm 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 271 column 12 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPshufb (va_op_xmm_xmm 12) (va_op_xmm_xmm 12) (va_op_xmm_xmm 0)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 272 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_opr128_xmm 15)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 273 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 1) (va_op_xmm_xmm 13) (va_op_xmm_xmm 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 274 column 12 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPshufb (va_op_xmm_xmm 13) (va_op_xmm_xmm 13) (va_op_xmm_xmm 0)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 275 column 12 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPshufb (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_xmm_xmm 0)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 276 column 12 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPshufb (va_op_xmm_xmm 1) (va_op_xmm_xmm 1) (va_op_xmm_xmm 0)) (va_QEmpty
(())))))))))))))))))))))
val va_lemma_Handle_ctr32 : va_b0:va_code -> va_s0:va_state -> ctr_BE:quad32
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Handle_ctr32 ()) va_s0 /\ va_get_ok va_s0 /\
(avx_enabled /\ sse_enabled /\ va_get_xmm 1 va_s0 == Vale.Def.Types_s.reverse_bytes_quad32
ctr_BE)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM, va_get_xmm 13 va_sM, va_get_xmm
14 va_sM, va_get_xmm 1 va_sM) == xor_reverse_inc32lite_6 2 1 ctr_BE (va_get_xmm 15 va_sM) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 14 va_sM (va_update_xmm 13 va_sM
(va_update_xmm 12 va_sM (va_update_xmm 11 va_sM (va_update_xmm 10 va_sM (va_update_xmm 6 va_sM
(va_update_xmm 5 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_xmm 0 va_sM
(va_update_reg64 rR11 va_sM (va_update_ok va_sM va_s0)))))))))))))))
[@"opaque_to_smt"]
let va_lemma_Handle_ctr32 va_b0 va_s0 ctr_BE =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm
11; va_Mod_xmm 10; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0;
va_Mod_reg64 rR11; va_Mod_ok] in
let va_qc = va_qcode_Handle_ctr32 va_mods ctr_BE in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_Handle_ctr32 ()) va_qc va_s0 (fun va_s0
va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 234 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 254 column 107 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM, va_get_xmm 13 va_sM,
va_get_xmm 14 va_sM, va_get_xmm 1 va_sM) == xor_reverse_inc32lite_6 2 1 ctr_BE (va_get_xmm 15
va_sM))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11;
va_Mod_xmm 10; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0;
va_Mod_reg64 rR11; va_Mod_ok]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Handle_ctr32 (ctr_BE:quad32) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (avx_enabled /\ sse_enabled /\ va_get_xmm 1 va_s0 ==
Vale.Def.Types_s.reverse_bytes_quad32 ctr_BE) /\ (forall (va_x_r11:nat64) (va_x_xmm0:quad32)
(va_x_xmm1:quad32) (va_x_xmm2:quad32) (va_x_xmm5:quad32) (va_x_xmm6:quad32) (va_x_xmm10:quad32)
(va_x_xmm11:quad32) (va_x_xmm12:quad32) (va_x_xmm13:quad32) (va_x_xmm14:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 14 va_x_xmm14
(va_upd_xmm 13 va_x_xmm13 (va_upd_xmm 12 va_x_xmm12 (va_upd_xmm 11 va_x_xmm11 (va_upd_xmm 10
va_x_xmm10 (va_upd_xmm 6 va_x_xmm6 (va_upd_xmm 5 va_x_xmm5 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm
1 va_x_xmm1 (va_upd_xmm 0 va_x_xmm0 (va_upd_reg64 rR11 va_x_r11 va_s0))))))))))) in va_get_ok
va_sM /\ (va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM, va_get_xmm 13 va_sM,
va_get_xmm 14 va_sM, va_get_xmm 1 va_sM) == xor_reverse_inc32lite_6 2 1 ctr_BE (va_get_xmm 15
va_sM) ==> va_k va_sM (())))
val va_wpProof_Handle_ctr32 : ctr_BE:quad32 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Handle_ctr32 ctr_BE va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Handle_ctr32 ()) ([va_Mod_flags;
va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 6;
va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_reg64 rR11]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Handle_ctr32 ctr_BE va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Handle_ctr32 (va_code_Handle_ctr32 ()) va_s0 ctr_BE in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 14 va_sM (va_update_xmm 13 va_sM
(va_update_xmm 12 va_sM (va_update_xmm 11 va_sM (va_update_xmm 10 va_sM (va_update_xmm 6 va_sM
(va_update_xmm 5 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_xmm 0 va_sM
(va_update_reg64 rR11 va_sM (va_update_ok va_sM va_s0))))))))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11;
va_Mod_xmm 10; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0;
va_Mod_reg64 rR11]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Handle_ctr32 (ctr_BE:quad32) : (va_quickCode unit (va_code_Handle_ctr32 ())) =
(va_QProc (va_code_Handle_ctr32 ()) ([va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12;
va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_xmm 0; va_Mod_reg64 rR11]) (va_wp_Handle_ctr32 ctr_BE) (va_wpProof_Handle_ctr32 ctr_BE))
//--
//-- Loop6x_ctr_update
val va_code_Loop6x_ctr_update : alg:algorithm -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_Loop6x_ctr_update alg =
(va_Block (va_CCons (va_code_Add64 (va_op_dst_opr64_reg64 rRbx) (va_const_opr64 6)) (va_CCons
(va_IfElse (va_cmp_ge (va_op_cmp_reg64 rRbx) (va_const_cmp 256)) (va_Block (va_CCons
(va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 3) (va_op_reg_opr64_reg64
rR9) (0 - 32) Secret) (va_CCons (va_code_Handle_ctr32 ()) (va_CCons (va_code_Sub64
(va_op_dst_opr64_reg64 rRbx) (va_const_opr64 256)) (va_CNil ()))))) (va_Block (va_CCons
(va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 3) (va_op_reg_opr64_reg64
rR9) (0 - 32) Secret) (va_CCons (va_code_VPaddd (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)
(va_op_xmm_xmm 14)) (va_CCons (va_code_VPxor (va_op_xmm_xmm 10) (va_op_xmm_xmm 10)
(va_op_opr128_xmm 15)) (va_CCons (va_code_VPxor (va_op_xmm_xmm 11) (va_op_xmm_xmm 11)
(va_op_opr128_xmm 15)) (va_CNil ()))))))) (va_CNil ()))))
val va_codegen_success_Loop6x_ctr_update : alg:algorithm -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_Loop6x_ctr_update alg =
(va_pbool_and (va_codegen_success_Add64 (va_op_dst_opr64_reg64 rRbx) (va_const_opr64 6))
(va_pbool_and (va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 3) (va_op_reg_opr64_reg64 rR9) (0 - 32) Secret) (va_pbool_and
(va_codegen_success_Handle_ctr32 ()) (va_pbool_and (va_codegen_success_Sub64
(va_op_dst_opr64_reg64 rRbx) (va_const_opr64 256)) (va_pbool_and
(va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 3)
(va_op_reg_opr64_reg64 rR9) (0 - 32) Secret) (va_pbool_and (va_codegen_success_VPaddd
(va_op_xmm_xmm 1) (va_op_xmm_xmm 2) (va_op_xmm_xmm 14)) (va_pbool_and (va_codegen_success_VPxor
(va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_opr128_xmm 15)) (va_codegen_success_VPxor
(va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_opr128_xmm 15)))))))) (va_ttrue ())))
[@ "opaque_to_smt" va_qattr]
let va_qcode_Loop6x_ctr_update (va_mods:va_mods_t) (alg:algorithm) (h_LE:quad32) (key_words:(seq
nat32)) (round_keys:(seq quad32)) (keys_b:buffer128) (hkeys_b:buffer128) (ctr_BE:quad32) :
(va_quickCode unit (va_code_Loop6x_ctr_update alg)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in let
(h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in va_QBind va_range1
"***** PRECONDITION NOT MET AT line 339 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Add64 (va_op_dst_opr64_reg64 rRbx) (va_const_opr64 6)) (fun (va_s:va_state) _ ->
va_QBind va_range1
"***** PRECONDITION NOT MET AT line 340 column 8 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_qIf va_mods (Cmp_ge (va_op_cmp_reg64 rRbx) (va_const_cmp 256)) (qblock va_mods (fun
(va_s:va_state) -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 341 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 3) (va_op_reg_opr64_reg64
rR9) (0 - 32) Secret hkeys_b 0) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 342 column 21 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Handle_ctr32 ctr_BE) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 343 column 14 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Sub64 (va_op_dst_opr64_reg64 rRbx) (va_const_opr64 256)) (va_QEmpty (())))))) (qblock
va_mods (fun (va_s:va_state) -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 345 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 3) (va_op_reg_opr64_reg64
rR9) (0 - 32) Secret hkeys_b 0) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 346 column 15 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 1) (va_op_xmm_xmm 2) (va_op_xmm_xmm 14)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 347 column 14 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_opr128_xmm 15)) (va_QBind
va_range1
"***** PRECONDITION NOT MET AT line 348 column 14 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_opr128_xmm 15)) (fun
(va_s:va_state) _ -> let (va_arg36:Prims.nat) = va_get_reg64 rRbx va_old_s in let
(va_arg35:Vale.Def.Types_s.quad32) = va_get_xmm 1 va_s in let
(va_arg34:Vale.Def.Types_s.quad32) = va_get_xmm 14 va_s in let
(va_arg33:Vale.Def.Types_s.quad32) = ctr_BE in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 349 column 28 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_msb_in_bounds va_arg33 va_arg34 va_arg35 va_arg36)
(va_QEmpty (()))))))))) (fun (va_s:va_state) va_g -> va_QEmpty (())))))
val va_lemma_Loop6x_ctr_update : va_b0:va_code -> va_s0:va_state -> alg:algorithm -> h_LE:quad32 ->
key_words:(seq nat32) -> round_keys:(seq quad32) -> keys_b:buffer128 -> hkeys_b:buffer128 ->
ctr_BE:quad32
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Loop6x_ctr_update alg) va_s0 /\ va_get_ok va_s0 /\
(let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in sse_enabled /\ aes_reqs_offset alg key_words
round_keys keys_b (va_get_reg64 rRcx va_s0) (va_get_mem_heaplet 0 va_s0) (va_get_mem_layout
va_s0) /\ va_get_xmm 2 va_s0 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 16777216
/\ va_get_xmm 1 va_s0 == Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE
0) /\ va_get_reg64 rRbx va_s0 == Vale.Def.Words_s.__proj__Mkfour__item__lo0 ctr_BE `op_Modulus`
256 /\ va_get_xmm 9 va_s0 == Vale.Def.Types_s.quad32_xor (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.AES.GCTR.inc32lite ctr_BE 0)) (va_get_xmm 15 va_s0) /\ (va_get_reg64 rRbx va_s0 + 6 < 256
==> (va_get_xmm 9 va_s0, va_get_xmm 10 va_s0, va_get_xmm 11 va_s0, va_get_xmm 12 va_s0,
va_get_xmm 13 va_s0, va_get_xmm 14 va_s0) == xor_reverse_inc32lite_6 1 0 ctr_BE (va_get_xmm 15
va_s0)) /\ hkeys_b_powers hkeys_b (va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0)
(va_get_reg64 rR9 va_s0 - 32) h)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in va_get_xmm 1 va_sM ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 6) /\ (0 <= va_get_reg64
rRbx va_sM /\ va_get_reg64 rRbx va_sM < 256) /\ va_get_reg64 rRbx va_sM ==
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (Vale.AES.GCTR.inc32lite ctr_BE 6) `op_Modulus` 256
/\ (va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM,
va_get_xmm 13 va_sM, va_get_xmm 14 va_sM) == xor_reverse_inc32lite_6 3 0 ctr_BE (va_get_xmm 15
va_sM) /\ va_get_xmm 3 va_sM == Vale.X64.Decls.buffer128_read hkeys_b 0 (va_get_mem_heaplet 0
va_sM)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 14 va_sM (va_update_xmm 13
va_sM (va_update_xmm 12 va_sM (va_update_xmm 11 va_sM (va_update_xmm 10 va_sM (va_update_xmm 9
va_sM (va_update_xmm 6 va_sM (va_update_xmm 5 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1
va_sM (va_update_xmm 0 va_sM (va_update_xmm 3 va_sM (va_update_reg64 rR11 va_sM
(va_update_reg64 rRbx va_sM (va_update_ok va_sM va_s0))))))))))))))))))
[@"opaque_to_smt"]
let va_lemma_Loop6x_ctr_update va_b0 va_s0 alg h_LE key_words round_keys keys_b hkeys_b ctr_BE =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm
11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_xmm 0; va_Mod_xmm 3; va_Mod_reg64 rR11; va_Mod_reg64 rRbx; va_Mod_ok] in
let va_qc = va_qcode_Loop6x_ctr_update va_mods alg h_LE key_words round_keys keys_b hkeys_b
ctr_BE in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_Loop6x_ctr_update alg) va_qc va_s0 (fun
va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 279 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_ok va_sM) /\ (let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in label va_range1
"***** POSTCONDITION NOT MET AT line 330 column 57 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_xmm 1 va_sM == Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE
6)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 331 column 27 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(0 <= va_get_reg64 rRbx va_sM /\ va_get_reg64 rRbx va_sM < 256) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 332 column 50 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_reg64 rRbx va_sM == Vale.Def.Words_s.__proj__Mkfour__item__lo0 (Vale.AES.GCTR.inc32lite
ctr_BE 6) `op_Modulus` 256) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 334 column 58 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM, va_get_xmm
13 va_sM, va_get_xmm 14 va_sM) == xor_reverse_inc32lite_6 3 0 ctr_BE (va_get_xmm 15 va_sM)) /\
label va_range1
"***** POSTCONDITION NOT MET AT line 335 column 50 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_xmm 3 va_sM == Vale.X64.Decls.buffer128_read hkeys_b 0 (va_get_mem_heaplet 0 va_sM))))
in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11;
va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm
0; va_Mod_xmm 3; va_Mod_reg64 rR11; va_Mod_reg64 rRbx; va_Mod_ok]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Loop6x_ctr_update (alg:algorithm) (h_LE:quad32) (key_words:(seq nat32)) (round_keys:(seq
quad32)) (keys_b:buffer128) (hkeys_b:buffer128) (ctr_BE:quad32) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in sse_enabled /\ aes_reqs_offset alg key_words
round_keys keys_b (va_get_reg64 rRcx va_s0) (va_get_mem_heaplet 0 va_s0) (va_get_mem_layout
va_s0) /\ va_get_xmm 2 va_s0 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 16777216
/\ va_get_xmm 1 va_s0 == Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE
0) /\ va_get_reg64 rRbx va_s0 == Vale.Def.Words_s.__proj__Mkfour__item__lo0 ctr_BE `op_Modulus`
256 /\ va_get_xmm 9 va_s0 == Vale.Def.Types_s.quad32_xor (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.AES.GCTR.inc32lite ctr_BE 0)) (va_get_xmm 15 va_s0) /\ (va_get_reg64 rRbx va_s0 + 6 < 256
==> (va_get_xmm 9 va_s0, va_get_xmm 10 va_s0, va_get_xmm 11 va_s0, va_get_xmm 12 va_s0,
va_get_xmm 13 va_s0, va_get_xmm 14 va_s0) == xor_reverse_inc32lite_6 1 0 ctr_BE (va_get_xmm 15
va_s0)) /\ hkeys_b_powers hkeys_b (va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0)
(va_get_reg64 rR9 va_s0 - 32) h) /\ (forall (va_x_rbx:nat64) (va_x_r11:nat64)
(va_x_xmm3:quad32) (va_x_xmm0:quad32) (va_x_xmm1:quad32) (va_x_xmm2:quad32) (va_x_xmm5:quad32)
(va_x_xmm6:quad32) (va_x_xmm9:quad32) (va_x_xmm10:quad32) (va_x_xmm11:quad32)
(va_x_xmm12:quad32) (va_x_xmm13:quad32) (va_x_xmm14:quad32) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (va_upd_xmm 14 va_x_xmm14 (va_upd_xmm 13 va_x_xmm13 (va_upd_xmm
12 va_x_xmm12 (va_upd_xmm 11 va_x_xmm11 (va_upd_xmm 10 va_x_xmm10 (va_upd_xmm 9 va_x_xmm9
(va_upd_xmm 6 va_x_xmm6 (va_upd_xmm 5 va_x_xmm5 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1
(va_upd_xmm 0 va_x_xmm0 (va_upd_xmm 3 va_x_xmm3 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rRbx
va_x_rbx va_s0)))))))))))))) in va_get_ok va_sM /\ (let (h:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in va_get_xmm 1
va_sM == Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 6) /\ (0 <=
va_get_reg64 rRbx va_sM /\ va_get_reg64 rRbx va_sM < 256) /\ va_get_reg64 rRbx va_sM ==
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (Vale.AES.GCTR.inc32lite ctr_BE 6) `op_Modulus` 256
/\ (va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM,
va_get_xmm 13 va_sM, va_get_xmm 14 va_sM) == xor_reverse_inc32lite_6 3 0 ctr_BE (va_get_xmm 15
va_sM) /\ va_get_xmm 3 va_sM == Vale.X64.Decls.buffer128_read hkeys_b 0 (va_get_mem_heaplet 0
va_sM)) ==> va_k va_sM (())))
val va_wpProof_Loop6x_ctr_update : alg:algorithm -> h_LE:quad32 -> key_words:(seq nat32) ->
round_keys:(seq quad32) -> keys_b:buffer128 -> hkeys_b:buffer128 -> ctr_BE:quad32 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Loop6x_ctr_update alg h_LE key_words round_keys keys_b
hkeys_b ctr_BE va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Loop6x_ctr_update alg) ([va_Mod_flags;
va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9;
va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_xmm 3;
va_Mod_reg64 rR11; va_Mod_reg64 rRbx]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Loop6x_ctr_update alg h_LE key_words round_keys keys_b hkeys_b ctr_BE va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Loop6x_ctr_update (va_code_Loop6x_ctr_update alg) va_s0 alg h_LE
key_words round_keys keys_b hkeys_b ctr_BE in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 14 va_sM (va_update_xmm 13 va_sM
(va_update_xmm 12 va_sM (va_update_xmm 11 va_sM (va_update_xmm 10 va_sM (va_update_xmm 9 va_sM
(va_update_xmm 6 va_sM (va_update_xmm 5 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM
(va_update_xmm 0 va_sM (va_update_xmm 3 va_sM (va_update_reg64 rR11 va_sM (va_update_reg64 rRbx
va_sM (va_update_ok va_sM va_s0)))))))))))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11;
va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm
0; va_Mod_xmm 3; va_Mod_reg64 rR11; va_Mod_reg64 rRbx]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Loop6x_ctr_update (alg:algorithm) (h_LE:quad32) (key_words:(seq nat32))
(round_keys:(seq quad32)) (keys_b:buffer128) (hkeys_b:buffer128) (ctr_BE:quad32) : (va_quickCode
unit (va_code_Loop6x_ctr_update alg)) =
(va_QProc (va_code_Loop6x_ctr_update alg) ([va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13;
va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 6; va_Mod_xmm 5;
va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_xmm 3; va_Mod_reg64 rR11; va_Mod_reg64 rRbx])
(va_wp_Loop6x_ctr_update alg h_LE key_words round_keys keys_b hkeys_b ctr_BE)
(va_wpProof_Loop6x_ctr_update alg h_LE key_words round_keys keys_b hkeys_b ctr_BE))
//--
//-- Loop6x_plain
val va_code_Loop6x_plain : alg:algorithm -> rnd:nat -> rndkey:va_operand_xmm -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Loop6x_plain alg rnd rndkey =
(va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) rndkey
(va_op_reg_opr64_reg64 rRcx) (16 `op_Multiply` (rnd + 1) - 128) Secret) (va_CCons
(va_code_VAESNI_enc (va_op_xmm_xmm 9) (va_op_xmm_xmm 9) rndkey) (va_CCons (va_code_VAESNI_enc
(va_op_xmm_xmm 10) (va_op_xmm_xmm 10) rndkey) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 11)
(va_op_xmm_xmm 11) rndkey) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 12) (va_op_xmm_xmm 12)
rndkey) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 13) (va_op_xmm_xmm 13) rndkey) (va_CCons
(va_code_VAESNI_enc (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) rndkey) (va_CNil ())))))))))
val va_codegen_success_Loop6x_plain : alg:algorithm -> rnd:nat -> rndkey:va_operand_xmm -> Tot
va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Loop6x_plain alg rnd rndkey =
(va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) rndkey
(va_op_reg_opr64_reg64 rRcx) (16 `op_Multiply` (rnd + 1) - 128) Secret) (va_pbool_and
(va_codegen_success_VAESNI_enc (va_op_xmm_xmm 9) (va_op_xmm_xmm 9) rndkey) (va_pbool_and
(va_codegen_success_VAESNI_enc (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) rndkey) (va_pbool_and
(va_codegen_success_VAESNI_enc (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) rndkey) (va_pbool_and
(va_codegen_success_VAESNI_enc (va_op_xmm_xmm 12) (va_op_xmm_xmm 12) rndkey) (va_pbool_and
(va_codegen_success_VAESNI_enc (va_op_xmm_xmm 13) (va_op_xmm_xmm 13) rndkey) (va_pbool_and
(va_codegen_success_VAESNI_enc (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) rndkey) (va_ttrue
()))))))))
val va_lemma_Loop6x_plain : va_b0:va_code -> va_s0:va_state -> alg:algorithm -> rnd:nat ->
key_words:(seq nat32) -> round_keys:(seq quad32) -> keys_b:buffer128 -> init:quad32_6 ->
rndkey:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Loop6x_plain alg rnd rndkey) va_s0 /\ va_is_dst_xmm
rndkey va_s0 /\ va_get_ok va_s0 /\ (sse_enabled /\ (rndkey == 1 \/ rndkey == 2 \/ rndkey == 15)
/\ aes_reqs_offset alg key_words round_keys keys_b (va_get_reg64 rRcx va_s0)
(va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0) /\ rnd + 1 < FStar.Seq.Base.length
#quad32 round_keys /\ (va_get_xmm 9 va_s0, va_get_xmm 10 va_s0, va_get_xmm 11 va_s0, va_get_xmm
12 va_s0, va_get_xmm 13 va_s0, va_get_xmm 14 va_s0) == rounds_opaque_6 init round_keys rnd)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM, va_get_xmm
13 va_sM, va_get_xmm 14 va_sM) == rounds_opaque_6 init round_keys (rnd + 1) /\ va_state_eq
va_sM (va_update_flags va_sM (va_update_xmm 14 va_sM (va_update_xmm 13 va_sM (va_update_xmm 12
va_sM (va_update_xmm 11 va_sM (va_update_xmm 10 va_sM (va_update_xmm 9 va_sM (va_update_ok
va_sM (va_update_operand_xmm rndkey va_sM va_s0)))))))))))
[@"opaque_to_smt"]
let va_lemma_Loop6x_plain va_b0 va_s0 alg rnd key_words round_keys keys_b init rndkey =
va_reveal_opaque (`%va_code_Loop6x_plain) (va_code_Loop6x_plain alg rnd rndkey);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let (va_s9, va_fc9) = va_lemma_Load128_buffer (va_hd va_b1) va_s0 (va_op_heaplet_mem_heaplet 0)
rndkey (va_op_reg_opr64_reg64 rRcx) (16 `op_Multiply` (rnd + 1) - 128) Secret keys_b (rnd + 1)
in
let va_b9 = va_tl va_b1 in
let (va_s10, va_fc10) = va_lemma_VAESNI_enc (va_hd va_b9) va_s9 (va_op_xmm_xmm 9) (va_op_xmm_xmm
9) rndkey in
let va_b10 = va_tl va_b9 in
let (va_s11, va_fc11) = va_lemma_VAESNI_enc (va_hd va_b10) va_s10 (va_op_xmm_xmm 10)
(va_op_xmm_xmm 10) rndkey in
let va_b11 = va_tl va_b10 in
let (va_s12, va_fc12) = va_lemma_VAESNI_enc (va_hd va_b11) va_s11 (va_op_xmm_xmm 11)
(va_op_xmm_xmm 11) rndkey in
let va_b12 = va_tl va_b11 in
let (va_s13, va_fc13) = va_lemma_VAESNI_enc (va_hd va_b12) va_s12 (va_op_xmm_xmm 12)
(va_op_xmm_xmm 12) rndkey in
let va_b13 = va_tl va_b12 in
let (va_s14, va_fc14) = va_lemma_VAESNI_enc (va_hd va_b13) va_s13 (va_op_xmm_xmm 13)
(va_op_xmm_xmm 13) rndkey in
let va_b14 = va_tl va_b13 in
let (va_s15, va_fc15) = va_lemma_VAESNI_enc (va_hd va_b14) va_s14 (va_op_xmm_xmm 14)
(va_op_xmm_xmm 14) rndkey in
let va_b15 = va_tl va_b14 in
Vale.AES.AES_s.eval_rounds_reveal ();
Vale.AES.AES_helpers.commute_sub_bytes_shift_rows_forall ();
let (va_sM, va_f15) = va_lemma_empty_total va_s15 va_b15 in
let va_f14 = va_lemma_merge_total va_b14 va_s14 va_fc15 va_s15 va_f15 va_sM in
let va_f13 = va_lemma_merge_total va_b13 va_s13 va_fc14 va_s14 va_f14 va_sM in
let va_f12 = va_lemma_merge_total va_b12 va_s12 va_fc13 va_s13 va_f13 va_sM in
let va_f11 = va_lemma_merge_total va_b11 va_s11 va_fc12 va_s12 va_f12 va_sM in
let va_f10 = va_lemma_merge_total va_b10 va_s10 va_fc11 va_s11 va_f11 va_sM in
let va_f9 = va_lemma_merge_total va_b9 va_s9 va_fc10 va_s10 va_f10 va_sM in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc9 va_s9 va_f9 va_sM in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Loop6x_plain (alg:algorithm) (rnd:nat) (key_words:(seq nat32)) (round_keys:(seq quad32))
(keys_b:buffer128) (init:quad32_6) (rndkey:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm rndkey va_s0 /\ va_get_ok va_s0 /\ (sse_enabled /\ (rndkey == 1 \/ rndkey == 2 \/
rndkey == 15) /\ aes_reqs_offset alg key_words round_keys keys_b (va_get_reg64 rRcx va_s0)
(va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0) /\ rnd + 1 < FStar.Seq.Base.length
#quad32 round_keys /\ (va_get_xmm 9 va_s0, va_get_xmm 10 va_s0, va_get_xmm 11 va_s0, va_get_xmm
12 va_s0, va_get_xmm 13 va_s0, va_get_xmm 14 va_s0) == rounds_opaque_6 init round_keys rnd) /\
(forall (va_x_rndkey:va_value_xmm) (va_x_xmm9:quad32) (va_x_xmm10:quad32) (va_x_xmm11:quad32)
(va_x_xmm12:quad32) (va_x_xmm13:quad32) (va_x_xmm14:quad32) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (va_upd_xmm 14 va_x_xmm14 (va_upd_xmm 13 va_x_xmm13 (va_upd_xmm
12 va_x_xmm12 (va_upd_xmm 11 va_x_xmm11 (va_upd_xmm 10 va_x_xmm10 (va_upd_xmm 9 va_x_xmm9
(va_upd_operand_xmm rndkey va_x_rndkey va_s0))))))) in va_get_ok va_sM /\ (va_get_xmm 9 va_sM,
va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM, va_get_xmm 13 va_sM, va_get_xmm
14 va_sM) == rounds_opaque_6 init round_keys (rnd + 1) ==> va_k va_sM (())))
val va_wpProof_Loop6x_plain : alg:algorithm -> rnd:nat -> key_words:(seq nat32) -> round_keys:(seq
quad32) -> keys_b:buffer128 -> init:quad32_6 -> rndkey:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Loop6x_plain alg rnd key_words round_keys keys_b init
rndkey va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Loop6x_plain alg rnd rndkey)
([va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10;
va_Mod_xmm 9; va_mod_xmm rndkey]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Loop6x_plain alg rnd key_words round_keys keys_b init rndkey va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Loop6x_plain (va_code_Loop6x_plain alg rnd rndkey) va_s0 alg rnd
key_words round_keys keys_b init rndkey in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 14 va_sM (va_update_xmm 13 va_sM
(va_update_xmm 12 va_sM (va_update_xmm 11 va_sM (va_update_xmm 10 va_sM (va_update_xmm 9 va_sM
(va_update_ok va_sM (va_update_operand_xmm rndkey va_sM va_s0))))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11;
va_Mod_xmm 10; va_Mod_xmm 9; va_mod_xmm rndkey]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Loop6x_plain (alg:algorithm) (rnd:nat) (key_words:(seq nat32)) (round_keys:(seq
quad32)) (keys_b:buffer128) (init:quad32_6) (rndkey:va_operand_xmm) : (va_quickCode unit
(va_code_Loop6x_plain alg rnd rndkey)) =
(va_QProc (va_code_Loop6x_plain alg rnd rndkey) ([va_Mod_flags; va_Mod_xmm 14; va_Mod_xmm 13;
va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_mod_xmm rndkey])
(va_wp_Loop6x_plain alg rnd key_words round_keys keys_b init rndkey) (va_wpProof_Loop6x_plain
alg rnd key_words round_keys keys_b init rndkey))
//--
//-- Loop6x_preamble
val va_code_Loop6x_preamble : alg:algorithm -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_Loop6x_preamble alg =
(va_Block (va_CCons (va_code_Loop6x_ctr_update alg) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp) (va_op_xmm_xmm 1) 128 Secret)
(va_CCons (va_code_VPxor (va_op_xmm_xmm 12) (va_op_xmm_xmm 12) (va_op_opr128_xmm 15)) (va_CCons
(va_code_VPxor (va_op_xmm_xmm 13) (va_op_xmm_xmm 13) (va_op_opr128_xmm 15)) (va_CCons
(va_code_VPxor (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_opr128_xmm 15)) (va_CNil ())))))))
val va_codegen_success_Loop6x_preamble : alg:algorithm -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_Loop6x_preamble alg =
(va_pbool_and (va_codegen_success_Loop6x_ctr_update alg) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp)
(va_op_xmm_xmm 1) 128 Secret) (va_pbool_and (va_codegen_success_VPxor (va_op_xmm_xmm 12)
(va_op_xmm_xmm 12) (va_op_opr128_xmm 15)) (va_pbool_and (va_codegen_success_VPxor
(va_op_xmm_xmm 13) (va_op_xmm_xmm 13) (va_op_opr128_xmm 15)) (va_pbool_and
(va_codegen_success_VPxor (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_opr128_xmm 15))
(va_ttrue ()))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_Loop6x_preamble (va_mods:va_mods_t) (alg:algorithm) (h_LE:quad32) (iv_b:buffer128)
(scratch_b:buffer128) (key_words:(seq nat32)) (round_keys:(seq quad32)) (keys_b:buffer128)
(hkeys_b:buffer128) (ctr_BE:quad32) : (va_quickCode unit (va_code_Loop6x_preamble alg)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in let
(h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in va_QBind va_range1
"***** PRECONDITION NOT MET AT line 477 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_ctr_update alg h_LE key_words round_keys keys_b hkeys_b ctr_BE) (fun
(va_s:va_state) _ -> let (va_arg43:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = round_keys
in let (va_arg42:Vale.Def.Types_s.quad32) = va_get_xmm 9 va_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 479 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.init_rounds_opaque va_arg42 va_arg43) (let
(va_arg41:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = round_keys in let
(va_arg40:Vale.Def.Types_s.quad32) = va_get_xmm 10 va_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 480 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.init_rounds_opaque va_arg40 va_arg41) (let
(va_arg39:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = round_keys in let
(va_arg38:Vale.Def.Types_s.quad32) = va_get_xmm 11 va_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 481 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.init_rounds_opaque va_arg38 va_arg39) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 498 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp)
(va_op_xmm_xmm 1) 128 Secret scratch_b 8) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 499 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 12) (va_op_xmm_xmm 12) (va_op_opr128_xmm 15)) (fun
(va_s:va_state) _ -> let (va_arg37:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = round_keys
in let (va_arg36:Vale.Def.Types_s.quad32) = va_get_xmm 12 va_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 499 column 54 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.init_rounds_opaque va_arg36 va_arg37) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 500 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 13) (va_op_xmm_xmm 13) (va_op_opr128_xmm 15)) (fun
(va_s:va_state) _ -> let (va_arg35:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = round_keys
in let (va_arg34:Vale.Def.Types_s.quad32) = va_get_xmm 13 va_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 500 column 54 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.init_rounds_opaque va_arg34 va_arg35) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 501 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_opr128_xmm 15)) (fun
(va_s:va_state) _ -> let (va_arg33:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = round_keys
in let (va_arg32:Vale.Def.Types_s.quad32) = va_get_xmm 14 va_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 501 column 54 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.init_rounds_opaque va_arg32 va_arg33) (va_QEmpty
(()))))))))))))))
val va_lemma_Loop6x_preamble : va_b0:va_code -> va_s0:va_state -> alg:algorithm -> h_LE:quad32 ->
iv_b:buffer128 -> scratch_b:buffer128 -> key_words:(seq nat32) -> round_keys:(seq quad32) ->
keys_b:buffer128 -> hkeys_b:buffer128 -> ctr_BE:quad32
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Loop6x_preamble alg) va_s0 /\ va_get_ok va_s0 /\ (let
(h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in sse_enabled /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 3 va_s0) (va_get_reg64 rRbp va_s0) scratch_b 9 (va_get_mem_layout va_s0)
Secret /\ aes_reqs_offset alg key_words round_keys keys_b (va_get_reg64 rRcx va_s0)
(va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0) /\ va_get_xmm 15 va_s0 ==
FStar.Seq.Base.index #quad32 round_keys 0 /\ va_get_xmm 2 va_s0 == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 0 0 0 16777216 /\ va_get_xmm 1 va_s0 ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 0) /\ va_get_reg64 rRbx
va_s0 == Vale.Def.Words_s.__proj__Mkfour__item__lo0 ctr_BE `op_Modulus` 256 /\ va_get_xmm 9
va_s0 == Vale.Def.Types_s.quad32_xor (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.AES.GCTR.inc32lite ctr_BE 0)) (va_get_xmm 15 va_s0) /\ (va_get_reg64 rRbx va_s0 + 6 < 256
==> (va_get_xmm 9 va_s0, va_get_xmm 10 va_s0, va_get_xmm 11 va_s0, va_get_xmm 12 va_s0,
va_get_xmm 13 va_s0, va_get_xmm 14 va_s0) == xor_reverse_inc32lite_6 1 0 ctr_BE (va_get_xmm 15
va_s0)) /\ hkeys_b_powers hkeys_b (va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0)
(va_get_reg64 rR9 va_s0 - 32) h)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in Vale.X64.Decls.modifies_buffer_specific128
scratch_b (va_get_mem_heaplet 3 va_s0) (va_get_mem_heaplet 3 va_sM) 8 8 /\ (let init =
make_six_of #Vale.Def.Types_s.quad32 (fun (n:(va_int_range 0 5)) -> Vale.Def.Types_s.quad32_xor
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE n)) (va_get_xmm 15
va_sM)) in (va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM,
va_get_xmm 13 va_sM, va_get_xmm 14 va_sM) == rounds_opaque_6 init round_keys 0 /\
Vale.X64.Decls.buffer128_read scratch_b 8 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 6) /\ (0 <= va_get_reg64
rRbx va_sM /\ va_get_reg64 rRbx va_sM < 256) /\ va_get_reg64 rRbx va_sM ==
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (Vale.AES.GCTR.inc32lite ctr_BE 6) `op_Modulus` 256
/\ va_get_xmm 3 va_sM == Vale.X64.Decls.buffer128_read hkeys_b 0 (va_get_mem_heaplet 0 va_s0)))
/\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 3 va_sM (va_update_xmm 14
va_sM (va_update_xmm 13 va_sM (va_update_xmm 12 va_sM (va_update_xmm 11 va_sM (va_update_xmm 10
va_sM (va_update_xmm 9 va_sM (va_update_xmm 6 va_sM (va_update_xmm 5 va_sM (va_update_xmm 2
va_sM (va_update_xmm 1 va_sM (va_update_xmm 0 va_sM (va_update_xmm 3 va_sM (va_update_reg64
rR11 va_sM (va_update_reg64 rRbx va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))))))))))))))))
[@"opaque_to_smt"]
let va_lemma_Loop6x_preamble va_b0 va_s0 alg h_LE iv_b scratch_b key_words round_keys keys_b
hkeys_b ctr_BE =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_mem_heaplet 3; va_Mod_xmm 14; va_Mod_xmm 13;
va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 6; va_Mod_xmm 5;
va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_xmm 3; va_Mod_reg64 rR11; va_Mod_reg64 rRbx;
va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_Loop6x_preamble va_mods alg h_LE iv_b scratch_b key_words round_keys keys_b
hkeys_b ctr_BE in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_Loop6x_preamble alg) va_qc va_s0 (fun
va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 402 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_ok va_sM) /\ (let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in label va_range1
"***** POSTCONDITION NOT MET AT line 459 column 72 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 scratch_b (va_get_mem_heaplet 3 va_s0)
(va_get_mem_heaplet 3 va_sM) 8 8) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 464 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(let init = make_six_of #Vale.Def.Types_s.quad32 (fun (n:(va_int_range 0 5)) ->
Vale.Def.Types_s.quad32_xor (Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite
ctr_BE n)) (va_get_xmm 15 va_sM)) in label va_range1
"***** POSTCONDITION NOT MET AT line 466 column 102 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM, va_get_xmm
13 va_sM, va_get_xmm 14 va_sM) == rounds_opaque_6 init round_keys 0) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 469 column 90 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 8 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 6)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 472 column 27 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(0 <= va_get_reg64 rRbx va_sM /\ va_get_reg64 rRbx va_sM < 256) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 473 column 50 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_reg64 rRbx va_sM == Vale.Def.Words_s.__proj__Mkfour__item__lo0 (Vale.AES.GCTR.inc32lite
ctr_BE 6) `op_Modulus` 256) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 475 column 55 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_xmm 3 va_sM == Vale.X64.Decls.buffer128_read hkeys_b 0 (va_get_mem_heaplet 0 va_s0)))))
in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_mem_heaplet 3; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm
12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2;
va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_xmm 3; va_Mod_reg64 rR11; va_Mod_reg64 rRbx; va_Mod_ok;
va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Loop6x_preamble (alg:algorithm) (h_LE:quad32) (iv_b:buffer128) (scratch_b:buffer128)
(key_words:(seq nat32)) (round_keys:(seq quad32)) (keys_b:buffer128) (hkeys_b:buffer128)
(ctr_BE:quad32) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in sse_enabled /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 3 va_s0) (va_get_reg64 rRbp va_s0) scratch_b 9 (va_get_mem_layout va_s0)
Secret /\ aes_reqs_offset alg key_words round_keys keys_b (va_get_reg64 rRcx va_s0)
(va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0) /\ va_get_xmm 15 va_s0 ==
FStar.Seq.Base.index #quad32 round_keys 0 /\ va_get_xmm 2 va_s0 == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 0 0 0 16777216 /\ va_get_xmm 1 va_s0 ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 0) /\ va_get_reg64 rRbx
va_s0 == Vale.Def.Words_s.__proj__Mkfour__item__lo0 ctr_BE `op_Modulus` 256 /\ va_get_xmm 9
va_s0 == Vale.Def.Types_s.quad32_xor (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.AES.GCTR.inc32lite ctr_BE 0)) (va_get_xmm 15 va_s0) /\ (va_get_reg64 rRbx va_s0 + 6 < 256
==> (va_get_xmm 9 va_s0, va_get_xmm 10 va_s0, va_get_xmm 11 va_s0, va_get_xmm 12 va_s0,
va_get_xmm 13 va_s0, va_get_xmm 14 va_s0) == xor_reverse_inc32lite_6 1 0 ctr_BE (va_get_xmm 15
va_s0)) /\ hkeys_b_powers hkeys_b (va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0)
(va_get_reg64 rR9 va_s0 - 32) h) /\ (forall (va_x_mem:vale_heap) (va_x_rbx:nat64)
(va_x_r11:nat64) (va_x_xmm3:quad32) (va_x_xmm0:quad32) (va_x_xmm1:quad32) (va_x_xmm2:quad32)
(va_x_xmm5:quad32) (va_x_xmm6:quad32) (va_x_xmm9:quad32) (va_x_xmm10:quad32)
(va_x_xmm11:quad32) (va_x_xmm12:quad32) (va_x_xmm13:quad32) (va_x_xmm14:quad32)
(va_x_heap3:vale_heap) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_mem_heaplet 3 va_x_heap3 (va_upd_xmm 14 va_x_xmm14 (va_upd_xmm 13 va_x_xmm13
(va_upd_xmm 12 va_x_xmm12 (va_upd_xmm 11 va_x_xmm11 (va_upd_xmm 10 va_x_xmm10 (va_upd_xmm 9
va_x_xmm9 (va_upd_xmm 6 va_x_xmm6 (va_upd_xmm 5 va_x_xmm5 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1
va_x_xmm1 (va_upd_xmm 0 va_x_xmm0 (va_upd_xmm 3 va_x_xmm3 (va_upd_reg64 rR11 va_x_r11
(va_upd_reg64 rRbx va_x_rbx (va_upd_mem va_x_mem va_s0)))))))))))))))) in va_get_ok va_sM /\
(let (h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in Vale.X64.Decls.modifies_buffer_specific128
scratch_b (va_get_mem_heaplet 3 va_s0) (va_get_mem_heaplet 3 va_sM) 8 8 /\ (let init =
make_six_of #Vale.Def.Types_s.quad32 (fun (n:(va_int_range 0 5)) -> Vale.Def.Types_s.quad32_xor
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE n)) (va_get_xmm 15
va_sM)) in (va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM,
va_get_xmm 13 va_sM, va_get_xmm 14 va_sM) == rounds_opaque_6 init round_keys 0 /\
Vale.X64.Decls.buffer128_read scratch_b 8 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 6) /\ (0 <= va_get_reg64
rRbx va_sM /\ va_get_reg64 rRbx va_sM < 256) /\ va_get_reg64 rRbx va_sM ==
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (Vale.AES.GCTR.inc32lite ctr_BE 6) `op_Modulus` 256
/\ va_get_xmm 3 va_sM == Vale.X64.Decls.buffer128_read hkeys_b 0 (va_get_mem_heaplet 0 va_s0)))
==> va_k va_sM (())))
val va_wpProof_Loop6x_preamble : alg:algorithm -> h_LE:quad32 -> iv_b:buffer128 ->
scratch_b:buffer128 -> key_words:(seq nat32) -> round_keys:(seq quad32) -> keys_b:buffer128 ->
hkeys_b:buffer128 -> ctr_BE:quad32 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Loop6x_preamble alg h_LE iv_b scratch_b key_words
round_keys keys_b hkeys_b ctr_BE va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Loop6x_preamble alg) ([va_Mod_flags;
va_Mod_mem_heaplet 3; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm
10; va_Mod_xmm 9; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0;
va_Mod_xmm 3; va_Mod_reg64 rR11; va_Mod_reg64 rRbx; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0,
va_g))))
[@"opaque_to_smt"]
let va_wpProof_Loop6x_preamble alg h_LE iv_b scratch_b key_words round_keys keys_b hkeys_b ctr_BE
va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Loop6x_preamble (va_code_Loop6x_preamble alg) va_s0 alg h_LE iv_b
scratch_b key_words round_keys keys_b hkeys_b ctr_BE in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 3 va_sM (va_update_xmm 14
va_sM (va_update_xmm 13 va_sM (va_update_xmm 12 va_sM (va_update_xmm 11 va_sM (va_update_xmm 10
va_sM (va_update_xmm 9 va_sM (va_update_xmm 6 va_sM (va_update_xmm 5 va_sM (va_update_xmm 2
va_sM (va_update_xmm 1 va_sM (va_update_xmm 0 va_sM (va_update_xmm 3 va_sM (va_update_reg64
rR11 va_sM (va_update_reg64 rRbx va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0)))))))))))))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_mem_heaplet 3; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm
12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 2;
va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_xmm 3; va_Mod_reg64 rR11; va_Mod_reg64 rRbx; va_Mod_mem])
va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Loop6x_preamble (alg:algorithm) (h_LE:quad32) (iv_b:buffer128) (scratch_b:buffer128)
(key_words:(seq nat32)) (round_keys:(seq quad32)) (keys_b:buffer128) (hkeys_b:buffer128)
(ctr_BE:quad32) : (va_quickCode unit (va_code_Loop6x_preamble alg)) =
(va_QProc (va_code_Loop6x_preamble alg) ([va_Mod_flags; va_Mod_mem_heaplet 3; va_Mod_xmm 14;
va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 6;
va_Mod_xmm 5; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_xmm 3; va_Mod_reg64 rR11;
va_Mod_reg64 rRbx; va_Mod_mem]) (va_wp_Loop6x_preamble alg h_LE iv_b scratch_b key_words
round_keys keys_b hkeys_b ctr_BE) (va_wpProof_Loop6x_preamble alg h_LE iv_b scratch_b key_words
round_keys keys_b hkeys_b ctr_BE))
//--
//-- Loop6x_reverse128
val va_code_Loop6x_reverse128 : in0_offset:nat -> stack_offset:nat -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_Loop6x_reverse128 in0_offset stack_offset =
(va_Block (va_CCons (va_code_LoadBe64_buffer128 (va_op_heaplet_mem_heaplet 6)
(va_op_reg_opr64_reg64 rR13) (va_op_reg_opr64_reg64 rR14) (in0_offset `op_Multiply` 16 + 8)
Secret true) (va_CCons (va_code_LoadBe64_buffer128 (va_op_heaplet_mem_heaplet 6)
(va_op_reg_opr64_reg64 rR12) (va_op_reg_opr64_reg64 rR14) (in0_offset `op_Multiply` 16) Secret
false) (va_CCons (va_code_Store64_buffer128 (va_op_heaplet_mem_heaplet 3)
(va_op_reg_opr64_reg64 rRbp) (va_op_reg_opr64_reg64 rR13) (stack_offset `op_Multiply` 16)
Secret false) (va_CCons (va_code_Store64_buffer128 (va_op_heaplet_mem_heaplet 3)
(va_op_reg_opr64_reg64 rRbp) (va_op_reg_opr64_reg64 rR12) (stack_offset `op_Multiply` 16 + 8)
Secret true) (va_CNil ()))))))
val va_codegen_success_Loop6x_reverse128 : in0_offset:nat -> stack_offset:nat -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_Loop6x_reverse128 in0_offset stack_offset =
(va_pbool_and (va_codegen_success_LoadBe64_buffer128 (va_op_heaplet_mem_heaplet 6)
(va_op_reg_opr64_reg64 rR13) (va_op_reg_opr64_reg64 rR14) (in0_offset `op_Multiply` 16 + 8)
Secret true) (va_pbool_and (va_codegen_success_LoadBe64_buffer128 (va_op_heaplet_mem_heaplet 6)
(va_op_reg_opr64_reg64 rR12) (va_op_reg_opr64_reg64 rR14) (in0_offset `op_Multiply` 16) Secret
false) (va_pbool_and (va_codegen_success_Store64_buffer128 (va_op_heaplet_mem_heaplet 3)
(va_op_reg_opr64_reg64 rRbp) (va_op_reg_opr64_reg64 rR13) (stack_offset `op_Multiply` 16)
Secret false) (va_pbool_and (va_codegen_success_Store64_buffer128 (va_op_heaplet_mem_heaplet 3)
(va_op_reg_opr64_reg64 rRbp) (va_op_reg_opr64_reg64 rR12) (stack_offset `op_Multiply` 16 + 8)
Secret true) (va_ttrue ())))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_Loop6x_reverse128 (va_mods:va_mods_t) (in0_offset:nat) (stack_offset:nat) (start:nat)
(in0_b:buffer128) (scratch_b:buffer128) : (va_quickCode unit (va_code_Loop6x_reverse128
in0_offset stack_offset)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 527 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_LoadBe64_buffer128 (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rR13)
(va_op_reg_opr64_reg64 rR14) (in0_offset `op_Multiply` 16 + 8) Secret true in0_b (start +
in0_offset)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 528 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_LoadBe64_buffer128 (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rR12)
(va_op_reg_opr64_reg64 rR14) (in0_offset `op_Multiply` 16) Secret false in0_b (start +
in0_offset)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 529 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store64_buffer128 (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp)
(va_op_reg_opr64_reg64 rR13) (stack_offset `op_Multiply` 16) Secret false scratch_b
stack_offset) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 530 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store64_buffer128 (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp)
(va_op_reg_opr64_reg64 rR12) (stack_offset `op_Multiply` 16 + 8) Secret true scratch_b
stack_offset) (fun (va_s:va_state) _ -> let (va_arg10:Vale.Def.Types_s.quad32) =
Vale.X64.Decls.buffer128_read scratch_b stack_offset (va_get_mem_heaplet 3 va_s) in let
(va_arg9:Vale.Def.Types_s.quad32) = Vale.X64.Decls.buffer128_read scratch_b stack_offset
(va_get_mem_heaplet 3 va_old_s) in let (va_arg8:Vale.Def.Types_s.quad32) =
Vale.X64.Decls.buffer128_read in0_b (start + in0_offset) (va_get_mem_heaplet 6 va_old_s) in
va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 531 column 34 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.Arch.Types.lemma_reverse_bytes_quad32_64 va_arg8 va_arg9 va_arg10)
(va_QEmpty (()))))))))
val va_lemma_Loop6x_reverse128 : va_b0:va_code -> va_s0:va_state -> in0_offset:nat ->
stack_offset:nat -> start:nat -> in0_b:buffer128 -> scratch_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Loop6x_reverse128 in0_offset stack_offset) va_s0 /\
va_get_ok va_s0 /\ (sse_enabled /\ movbe_enabled /\ Vale.X64.Decls.validSrcAddrsOffset128
(va_get_mem_heaplet 6 va_s0) (va_get_reg64 rR14 va_s0) in0_b start (in0_offset + 1)
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 3
va_s0) (va_get_reg64 rRbp va_s0) scratch_b (stack_offset + 1) (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 /\
(Vale.X64.Decls.modifies_buffer_specific128 scratch_b (va_get_mem_heaplet 3 va_s0)
(va_get_mem_heaplet 3 va_sM) stack_offset stack_offset /\ Vale.X64.Decls.buffer128_read
scratch_b stack_offset (va_get_mem_heaplet 3 va_sM) == Vale.Def.Types_s.reverse_bytes_quad32
(Vale.X64.Decls.buffer128_read in0_b (start + in0_offset) (va_get_mem_heaplet 6 va_s0))) /\
va_state_eq va_sM (va_update_mem_heaplet 3 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64
rR12 va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))
[@"opaque_to_smt"]
let va_lemma_Loop6x_reverse128 va_b0 va_s0 in0_offset stack_offset start in0_b scratch_b =
let (va_mods:va_mods_t) = [va_Mod_mem_heaplet 3; va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_ok;
va_Mod_mem] in
let va_qc = va_qcode_Loop6x_reverse128 va_mods in0_offset stack_offset start in0_b scratch_b in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_Loop6x_reverse128 in0_offset
stack_offset) va_qc va_s0 (fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 504 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_ok va_sM) /\ (label va_range1
"***** POSTCONDITION NOT MET AT line 523 column 94 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 scratch_b (va_get_mem_heaplet 3 va_s0)
(va_get_mem_heaplet 3 va_sM) stack_offset stack_offset) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 525 column 88 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b stack_offset (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b (start + in0_offset)
(va_get_mem_heaplet 6 va_s0))))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_mem_heaplet 3; va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_ok;
va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Loop6x_reverse128 (in0_offset:nat) (stack_offset:nat) (start:nat) (in0_b:buffer128)
(scratch_b:buffer128) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (sse_enabled /\ movbe_enabled /\ Vale.X64.Decls.validSrcAddrsOffset128
(va_get_mem_heaplet 6 va_s0) (va_get_reg64 rR14 va_s0) in0_b start (in0_offset + 1)
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 3
va_s0) (va_get_reg64 rRbp va_s0) scratch_b (stack_offset + 1) (va_get_mem_layout va_s0) Secret)
/\ (forall (va_x_mem:vale_heap) (va_x_r12:nat64) (va_x_r13:nat64) (va_x_heap3:vale_heap) . let
va_sM = va_upd_mem_heaplet 3 va_x_heap3 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rR12 va_x_r12
(va_upd_mem va_x_mem va_s0))) in va_get_ok va_sM /\ (Vale.X64.Decls.modifies_buffer_specific128
scratch_b (va_get_mem_heaplet 3 va_s0) (va_get_mem_heaplet 3 va_sM) stack_offset stack_offset
/\ Vale.X64.Decls.buffer128_read scratch_b stack_offset (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b (start + in0_offset)
(va_get_mem_heaplet 6 va_s0))) ==> va_k va_sM (())))
val va_wpProof_Loop6x_reverse128 : in0_offset:nat -> stack_offset:nat -> start:nat ->
in0_b:buffer128 -> scratch_b:buffer128 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Loop6x_reverse128 in0_offset stack_offset start in0_b
scratch_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Loop6x_reverse128 in0_offset
stack_offset) ([va_Mod_mem_heaplet 3; va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Loop6x_reverse128 in0_offset stack_offset start in0_b scratch_b va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Loop6x_reverse128 (va_code_Loop6x_reverse128 in0_offset
stack_offset) va_s0 in0_offset stack_offset start in0_b scratch_b in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_mem_heaplet 3 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR12 va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))));
va_lemma_norm_mods ([va_Mod_mem_heaplet 3; va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_mem])
va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Loop6x_reverse128 (in0_offset:nat) (stack_offset:nat) (start:nat) (in0_b:buffer128)
(scratch_b:buffer128) : (va_quickCode unit (va_code_Loop6x_reverse128 in0_offset stack_offset)) =
(va_QProc (va_code_Loop6x_reverse128 in0_offset stack_offset) ([va_Mod_mem_heaplet 3;
va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_mem]) (va_wp_Loop6x_reverse128 in0_offset
stack_offset start in0_b scratch_b) (va_wpProof_Loop6x_reverse128 in0_offset stack_offset start
in0_b scratch_b))
//--
//-- Loop6x_round9
val va_code_Loop6x_round9 : alg:algorithm -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_Loop6x_round9 alg =
(va_Block (va_CCons (va_code_Store128_buffer (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64
rRbp) (va_op_xmm_xmm 7) 16 Secret) (va_CCons (va_code_Mem128_lemma ()) (va_CCons (va_code_VPxor
(va_op_xmm_xmm 2) (va_op_xmm_xmm 1) (va_opr_code_Mem128 (va_op_heaplet_mem_heaplet 6)
(va_op_reg64_reg64 rRdi) 0 Secret)) (va_CCons (va_code_Mem128_lemma ()) (va_CCons
(va_code_VPxor (va_op_xmm_xmm 0) (va_op_xmm_xmm 1) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 16 Secret)) (va_CCons
(va_code_Mem128_lemma ()) (va_CCons (va_code_VPxor (va_op_xmm_xmm 5) (va_op_xmm_xmm 1)
(va_opr_code_Mem128 (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 32 Secret))
(va_CCons (va_code_Mem128_lemma ()) (va_CCons (va_code_VPxor (va_op_xmm_xmm 6) (va_op_xmm_xmm
1) (va_opr_code_Mem128 (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 48 Secret))
(va_CCons (va_code_Mem128_lemma ()) (va_CCons (va_code_VPxor (va_op_xmm_xmm 7) (va_op_xmm_xmm
1) (va_opr_code_Mem128 (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 64 Secret))
(va_CCons (va_code_Mem128_lemma ()) (va_CCons (va_code_VPxor (va_op_xmm_xmm 3) (va_op_xmm_xmm
1) (va_opr_code_Mem128 (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 80 Secret))
(va_CNil ())))))))))))))))
val va_codegen_success_Loop6x_round9 : alg:algorithm -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_Loop6x_round9 alg =
(va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 3)
(va_op_reg_opr64_reg64 rRbp) (va_op_xmm_xmm 7) 16 Secret) (va_pbool_and
(va_codegen_success_Mem128_lemma ()) (va_pbool_and (va_codegen_success_VPxor (va_op_xmm_xmm 2)
(va_op_xmm_xmm 1) (va_opr_code_Mem128 (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 0
Secret)) (va_pbool_and (va_codegen_success_Mem128_lemma ()) (va_pbool_and
(va_codegen_success_VPxor (va_op_xmm_xmm 0) (va_op_xmm_xmm 1) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 16 Secret)) (va_pbool_and
(va_codegen_success_Mem128_lemma ()) (va_pbool_and (va_codegen_success_VPxor (va_op_xmm_xmm 5)
(va_op_xmm_xmm 1) (va_opr_code_Mem128 (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 32
Secret)) (va_pbool_and (va_codegen_success_Mem128_lemma ()) (va_pbool_and
(va_codegen_success_VPxor (va_op_xmm_xmm 6) (va_op_xmm_xmm 1) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 48 Secret)) (va_pbool_and
(va_codegen_success_Mem128_lemma ()) (va_pbool_and (va_codegen_success_VPxor (va_op_xmm_xmm 7)
(va_op_xmm_xmm 1) (va_opr_code_Mem128 (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 64
Secret)) (va_pbool_and (va_codegen_success_Mem128_lemma ()) (va_pbool_and
(va_codegen_success_VPxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 1) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 80 Secret)) (va_ttrue ()))))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_Loop6x_round9 (va_mods:va_mods_t) (alg:algorithm) (count:nat) (in_b:buffer128)
(scratch_b:buffer128) (key_words:(seq nat32)) (round_keys:(seq quad32)) (keys_b:buffer128) :
(va_quickCode unit (va_code_Loop6x_round9 alg)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 567 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp)
(va_op_xmm_xmm 7) 16 Secret scratch_b 1) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 568 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mem128_lemma (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 0 Secret in_b
(count `op_Multiply` 6 + 0)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 568 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 0 Secret)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 569 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mem128_lemma (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 16 Secret in_b
(count `op_Multiply` 6 + 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 569 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 0) (va_op_xmm_xmm 1) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 16 Secret)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 570 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mem128_lemma (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 32 Secret in_b
(count `op_Multiply` 6 + 2)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 570 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 5) (va_op_xmm_xmm 1) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 32 Secret)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 571 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mem128_lemma (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 48 Secret in_b
(count `op_Multiply` 6 + 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 571 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 6) (va_op_xmm_xmm 1) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 48 Secret)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 572 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mem128_lemma (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 64 Secret in_b
(count `op_Multiply` 6 + 4)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 572 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 7) (va_op_xmm_xmm 1) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 64 Secret)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 573 column 28 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mem128_lemma (va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 80 Secret in_b
(count `op_Multiply` 6 + 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 573 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 1) (va_opr_code_Mem128
(va_op_heaplet_mem_heaplet 6) (va_op_reg64_reg64 rRdi) 80 Secret)) (va_QEmpty
(()))))))))))))))))
val va_lemma_Loop6x_round9 : va_b0:va_code -> va_s0:va_state -> alg:algorithm -> count:nat ->
in_b:buffer128 -> scratch_b:buffer128 -> key_words:(seq nat32) -> round_keys:(seq quad32) ->
keys_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Loop6x_round9 alg) va_s0 /\ va_get_ok va_s0 /\
(sse_enabled /\ Vale.X64.Decls.validSrcAddrsOffset128 (va_get_mem_heaplet 6 va_s0)
(va_get_reg64 rRdi va_s0) in_b (count `op_Multiply` 6) 6 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 3 va_s0) (va_get_reg64 rRbp va_s0)
scratch_b 8 (va_get_mem_layout va_s0) Secret /\ aes_reqs_offset alg key_words round_keys keys_b
(va_get_reg64 rRcx va_s0) (va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0) /\ va_get_xmm
1 va_s0 == Vale.X64.Decls.buffer128_read keys_b (Vale.AES.AES_common_s.nr alg)
(va_get_mem_heaplet 0 va_s0))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(Vale.X64.Decls.modifies_buffer_specific128 scratch_b (va_get_mem_heaplet 3 va_s0)
(va_get_mem_heaplet 3 va_sM) 1 1 /\ (va_get_xmm 2 va_sM, va_get_xmm 0 va_sM, va_get_xmm 5
va_sM, va_get_xmm 6 va_sM, va_get_xmm 7 va_sM, va_get_xmm 3 va_sM) == make_six_of #quad32 (fun
(i:(va_int_range 0 5)) -> Vale.Def.Types_s.quad32_xor (FStar.Seq.Base.index
#Vale.Def.Types_s.quad32 round_keys (Vale.AES.AES_common_s.nr alg))
(Vale.X64.Decls.buffer128_read in_b (count `op_Multiply` 6 + i) (va_get_mem_heaplet 6 va_sM)))
/\ Vale.X64.Decls.buffer128_read scratch_b 1 (va_get_mem_heaplet 3 va_sM) == va_get_xmm 7
va_s0) /\ va_state_eq va_sM (va_update_mem_heaplet 3 va_sM (va_update_flags va_sM
(va_update_xmm 7 va_sM (va_update_xmm 6 va_sM (va_update_xmm 5 va_sM (va_update_xmm 3 va_sM
(va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_xmm 0 va_sM (va_update_ok va_sM
(va_update_mem va_sM va_s0)))))))))))))
[@"opaque_to_smt"]
let va_lemma_Loop6x_round9 va_b0 va_s0 alg count in_b scratch_b key_words round_keys keys_b =
let (va_mods:va_mods_t) = [va_Mod_mem_heaplet 3; va_Mod_flags; va_Mod_xmm 7; va_Mod_xmm 6;
va_Mod_xmm 5; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_Loop6x_round9 va_mods alg count in_b scratch_b key_words round_keys keys_b in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_Loop6x_round9 alg) va_qc va_s0 (fun
va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 535 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_ok va_sM) /\ (label va_range1
"***** POSTCONDITION NOT MET AT line 561 column 72 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 scratch_b (va_get_mem_heaplet 3 va_s0)
(va_get_mem_heaplet 3 va_sM) 1 1) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 563 column 102 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((va_get_xmm 2 va_sM, va_get_xmm 0 va_sM, va_get_xmm 5 va_sM, va_get_xmm 6 va_sM, va_get_xmm 7
va_sM, va_get_xmm 3 va_sM) == make_six_of #quad32 (fun (i:(va_int_range 0 5)) ->
Vale.Def.Types_s.quad32_xor (FStar.Seq.Base.index #Vale.Def.Types_s.quad32 round_keys
(Vale.AES.AES_common_s.nr alg)) (Vale.X64.Decls.buffer128_read in_b (count `op_Multiply` 6 + i)
(va_get_mem_heaplet 6 va_sM)))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 564 column 55 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 1 (va_get_mem_heaplet 3 va_sM) == va_get_xmm 7
va_s0))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_mem_heaplet 3; va_Mod_flags; va_Mod_xmm 7; va_Mod_xmm 6; va_Mod_xmm
5; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Loop6x_round9 (alg:algorithm) (count:nat) (in_b:buffer128) (scratch_b:buffer128)
(key_words:(seq nat32)) (round_keys:(seq quad32)) (keys_b:buffer128) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (sse_enabled /\ Vale.X64.Decls.validSrcAddrsOffset128 (va_get_mem_heaplet 6
va_s0) (va_get_reg64 rRdi va_s0) in_b (count `op_Multiply` 6) 6 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 3 va_s0) (va_get_reg64 rRbp
va_s0) scratch_b 8 (va_get_mem_layout va_s0) Secret /\ aes_reqs_offset alg key_words round_keys
keys_b (va_get_reg64 rRcx va_s0) (va_get_mem_heaplet 0 va_s0) (va_get_mem_layout va_s0) /\
va_get_xmm 1 va_s0 == Vale.X64.Decls.buffer128_read keys_b (Vale.AES.AES_common_s.nr alg)
(va_get_mem_heaplet 0 va_s0)) /\ (forall (va_x_mem:vale_heap) (va_x_xmm0:quad32)
(va_x_xmm1:quad32) (va_x_xmm2:quad32) (va_x_xmm3:quad32) (va_x_xmm5:quad32) (va_x_xmm6:quad32)
(va_x_xmm7:quad32) (va_x_efl:Vale.X64.Flags.t) (va_x_heap3:vale_heap) . let va_sM =
va_upd_mem_heaplet 3 va_x_heap3 (va_upd_flags va_x_efl (va_upd_xmm 7 va_x_xmm7 (va_upd_xmm 6
va_x_xmm6 (va_upd_xmm 5 va_x_xmm5 (va_upd_xmm 3 va_x_xmm3 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1
va_x_xmm1 (va_upd_xmm 0 va_x_xmm0 (va_upd_mem va_x_mem va_s0))))))))) in va_get_ok va_sM /\
(Vale.X64.Decls.modifies_buffer_specific128 scratch_b (va_get_mem_heaplet 3 va_s0)
(va_get_mem_heaplet 3 va_sM) 1 1 /\ (va_get_xmm 2 va_sM, va_get_xmm 0 va_sM, va_get_xmm 5
va_sM, va_get_xmm 6 va_sM, va_get_xmm 7 va_sM, va_get_xmm 3 va_sM) == make_six_of #quad32 (fun
(i:(va_int_range 0 5)) -> Vale.Def.Types_s.quad32_xor (FStar.Seq.Base.index
#Vale.Def.Types_s.quad32 round_keys (Vale.AES.AES_common_s.nr alg))
(Vale.X64.Decls.buffer128_read in_b (count `op_Multiply` 6 + i) (va_get_mem_heaplet 6 va_sM)))
/\ Vale.X64.Decls.buffer128_read scratch_b 1 (va_get_mem_heaplet 3 va_sM) == va_get_xmm 7
va_s0) ==> va_k va_sM (())))
val va_wpProof_Loop6x_round9 : alg:algorithm -> count:nat -> in_b:buffer128 -> scratch_b:buffer128
-> key_words:(seq nat32) -> round_keys:(seq quad32) -> keys_b:buffer128 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Loop6x_round9 alg count in_b scratch_b key_words
round_keys keys_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Loop6x_round9 alg)
([va_Mod_mem_heaplet 3; va_Mod_flags; va_Mod_xmm 7; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 3;
va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Loop6x_round9 alg count in_b scratch_b key_words round_keys keys_b va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Loop6x_round9 (va_code_Loop6x_round9 alg) va_s0 alg count in_b
scratch_b key_words round_keys keys_b in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_mem_heaplet 3 va_sM (va_update_flags va_sM (va_update_xmm 7
va_sM (va_update_xmm 6 va_sM (va_update_xmm 5 va_sM (va_update_xmm 3 va_sM (va_update_xmm 2
va_sM (va_update_xmm 1 va_sM (va_update_xmm 0 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))))))));
va_lemma_norm_mods ([va_Mod_mem_heaplet 3; va_Mod_flags; va_Mod_xmm 7; va_Mod_xmm 6; va_Mod_xmm
5; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Loop6x_round9 (alg:algorithm) (count:nat) (in_b:buffer128) (scratch_b:buffer128)
(key_words:(seq nat32)) (round_keys:(seq quad32)) (keys_b:buffer128) : (va_quickCode unit
(va_code_Loop6x_round9 alg)) =
(va_QProc (va_code_Loop6x_round9 alg) ([va_Mod_mem_heaplet 3; va_Mod_flags; va_Mod_xmm 7;
va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0;
va_Mod_mem]) (va_wp_Loop6x_round9 alg count in_b scratch_b key_words round_keys keys_b)
(va_wpProof_Loop6x_round9 alg count in_b scratch_b key_words round_keys keys_b))
//--
//-- load_one_msb
val va_code_load_one_msb : va_dummy:unit -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_load_one_msb () =
(va_Block (va_CCons (va_code_ZeroXmm (va_op_xmm_xmm 2)) (va_CCons (va_code_PinsrqImm
(va_op_xmm_xmm 2) 72057594037927936 1 (va_op_reg_opr64_reg64 rR11)) (va_CNil ()))))
val va_codegen_success_load_one_msb : va_dummy:unit -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_load_one_msb () =
(va_pbool_and (va_codegen_success_ZeroXmm (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_PinsrqImm (va_op_xmm_xmm 2) 72057594037927936 1 (va_op_reg_opr64_reg64
rR11)) (va_ttrue ())))
[@ "opaque_to_smt" va_qattr]
let va_qcode_load_one_msb (va_mods:va_mods_t) : (va_quickCode unit (va_code_load_one_msb ())) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QBind va_range1
"***** PRECONDITION NOT MET AT line 583 column 12 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_ZeroXmm (va_op_xmm_xmm 2)) (fun (va_s:va_state) _ -> va_qAssert va_range1
"***** PRECONDITION NOT MET AT line 584 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.Arch.Types.two_to_nat32 (Vale.Def.Words_s.Mktwo #Vale.Def.Words_s.nat32 0 16777216) ==
72057594037927936) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 585 column 14 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_PinsrqImm (va_op_xmm_xmm 2) 72057594037927936 1 (va_op_reg_opr64_reg64 rR11)) (fun
(va_s:va_state) _ -> va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 586 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.Def.Types_s.insert_nat64_reveal ()) (va_QEmpty (())))))))
val va_lemma_load_one_msb : va_b0:va_code -> va_s0:va_state
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_load_one_msb ()) va_s0 /\ va_get_ok va_s0 /\
sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_xmm 2 va_sM == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 16777216 /\
va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 2 va_sM (va_update_reg64 rR11 va_sM
(va_update_ok va_sM va_s0))))))
[@"opaque_to_smt"]
let va_lemma_load_one_msb va_b0 va_s0 =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 2; va_Mod_reg64 rR11; va_Mod_ok] in
let va_qc = va_qcode_load_one_msb va_mods in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_load_one_msb ()) va_qc va_s0 (fun va_s0
va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 576 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 581 column 46 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_xmm 2 va_sM == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 16777216)) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 2; va_Mod_reg64 rR11; va_Mod_ok]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_load_one_msb (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ sse_enabled /\ (forall (va_x_r11:nat64) (va_x_xmm2:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 2 va_x_xmm2
(va_upd_reg64 rR11 va_x_r11 va_s0)) in va_get_ok va_sM /\ va_get_xmm 2 va_sM ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 16777216 ==> va_k va_sM (())))
val va_wpProof_load_one_msb : va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_load_one_msb va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_load_one_msb ()) ([va_Mod_flags;
va_Mod_xmm 2; va_Mod_reg64 rR11]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_load_one_msb va_s0 va_k =
let (va_sM, va_f0) = va_lemma_load_one_msb (va_code_load_one_msb ()) va_s0 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 2 va_sM (va_update_reg64 rR11
va_sM (va_update_ok va_sM va_s0)))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 2; va_Mod_reg64 rR11]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_load_one_msb () : (va_quickCode unit (va_code_load_one_msb ())) =
(va_QProc (va_code_load_one_msb ()) ([va_Mod_flags; va_Mod_xmm 2; va_Mod_reg64 rR11])
va_wp_load_one_msb va_wpProof_load_one_msb)
//--
//-- Loop6x_final
[@ "opaque_to_smt" va_qattr]
let va_code_Loop6x_final alg =
(va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 3) (va_op_xmm_xmm 1)
(va_op_reg_opr64_reg64 rRbp) 128 Secret) (va_CCons (va_code_VAESNI_enc_last (va_op_xmm_xmm 9)
(va_op_xmm_xmm 9) (va_op_xmm_xmm 2)) (va_CCons (va_code_load_one_msb ()) (va_CCons
(va_code_VAESNI_enc_last (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_xmm_xmm 0)) (va_CCons
(va_code_VPaddd (va_op_xmm_xmm 0) (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_CCons
(va_code_Store64_buffer128 (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp)
(va_op_reg_opr64_reg64 rR13) (7 `op_Multiply` 16) Secret false) (va_CCons (va_code_AddLea64
(va_op_dst_opr64_reg64 rRdi) (va_op_opr64_reg64 rRdi) (va_const_opr64 96)) (va_CCons
(va_code_VAESNI_enc_last (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_xmm_xmm 5)) (va_CCons
(va_code_VPaddd (va_op_xmm_xmm 5) (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_CCons
(va_code_Store64_buffer128 (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp)
(va_op_reg_opr64_reg64 rR12) (7 `op_Multiply` 16 + 8) Secret true) (va_CCons (va_code_AddLea64
(va_op_dst_opr64_reg64 rRsi) (va_op_opr64_reg64 rRsi) (va_const_opr64 96)) (va_CCons
(va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 15) (va_op_reg_opr64_reg64
rRcx) (0 - 128) Secret) (va_CCons (va_code_VAESNI_enc_last (va_op_xmm_xmm 12) (va_op_xmm_xmm
12) (va_op_xmm_xmm 6)) (va_CCons (va_code_VPaddd (va_op_xmm_xmm 6) (va_op_xmm_xmm 5)
(va_op_xmm_xmm 2)) (va_CCons (va_code_VAESNI_enc_last (va_op_xmm_xmm 13) (va_op_xmm_xmm 13)
(va_op_xmm_xmm 7)) (va_CCons (va_code_VPaddd (va_op_xmm_xmm 7) (va_op_xmm_xmm 6) (va_op_xmm_xmm
2)) (va_CCons (va_code_VAESNI_enc_last (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_xmm_xmm 3))
(va_CCons (va_code_VPaddd (va_op_xmm_xmm 3) (va_op_xmm_xmm 7) (va_op_xmm_xmm 2)) (va_CNil
()))))))))))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_Loop6x_final alg =
(va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 3) (va_op_xmm_xmm 1)
(va_op_reg_opr64_reg64 rRbp) 128 Secret) (va_pbool_and (va_codegen_success_VAESNI_enc_last
(va_op_xmm_xmm 9) (va_op_xmm_xmm 9) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_load_one_msb ()) (va_pbool_and (va_codegen_success_VAESNI_enc_last
(va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_xmm_xmm 0)) (va_pbool_and
(va_codegen_success_VPaddd (va_op_xmm_xmm 0) (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Store64_buffer128 (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64
rRbp) (va_op_reg_opr64_reg64 rR13) (7 `op_Multiply` 16) Secret false) (va_pbool_and
(va_codegen_success_AddLea64 (va_op_dst_opr64_reg64 rRdi) (va_op_opr64_reg64 rRdi)
(va_const_opr64 96)) (va_pbool_and (va_codegen_success_VAESNI_enc_last (va_op_xmm_xmm 11)
(va_op_xmm_xmm 11) (va_op_xmm_xmm 5)) (va_pbool_and (va_codegen_success_VPaddd (va_op_xmm_xmm
5) (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_pbool_and (va_codegen_success_Store64_buffer128
(va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp) (va_op_reg_opr64_reg64 rR12) (7
`op_Multiply` 16 + 8) Secret true) (va_pbool_and (va_codegen_success_AddLea64
(va_op_dst_opr64_reg64 rRsi) (va_op_opr64_reg64 rRsi) (va_const_opr64 96)) (va_pbool_and
(va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 15)
(va_op_reg_opr64_reg64 rRcx) (0 - 128) Secret) (va_pbool_and
(va_codegen_success_VAESNI_enc_last (va_op_xmm_xmm 12) (va_op_xmm_xmm 12) (va_op_xmm_xmm 6))
(va_pbool_and (va_codegen_success_VPaddd (va_op_xmm_xmm 6) (va_op_xmm_xmm 5) (va_op_xmm_xmm 2))
(va_pbool_and (va_codegen_success_VAESNI_enc_last (va_op_xmm_xmm 13) (va_op_xmm_xmm 13)
(va_op_xmm_xmm 7)) (va_pbool_and (va_codegen_success_VPaddd (va_op_xmm_xmm 7) (va_op_xmm_xmm 6)
(va_op_xmm_xmm 2)) (va_pbool_and (va_codegen_success_VAESNI_enc_last (va_op_xmm_xmm 14)
(va_op_xmm_xmm 14) (va_op_xmm_xmm 3)) (va_pbool_and (va_codegen_success_VPaddd (va_op_xmm_xmm
3) (va_op_xmm_xmm 7) (va_op_xmm_xmm 2)) (va_ttrue ())))))))))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_Loop6x_final (va_mods:va_mods_t) (alg:algorithm) (iv_b:buffer128)
(scratch_b:buffer128) (key_words:(seq nat32)) (round_keys:(seq quad32)) (keys_b:buffer128)
(ctr_orig:quad32) (init:quad32_6) (ctrs:quad32_6) (plain:quad32_6) (inb:quad32) : (va_quickCode
unit (va_code_Loop6x_final alg)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 667 column 37 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.Arch.TypesNative.lemma_quad32_xor_commutes_forall ()) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 669 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 3) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRbp) 128 Secret scratch_b 8) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 671 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc_last (va_op_xmm_xmm 9) (va_op_xmm_xmm 9) (va_op_xmm_xmm 2)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 672 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_load_one_msb ()) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 673 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc_last (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_xmm_xmm 0)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 674 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 0) (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 675 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store64_buffer128 (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp)
(va_op_reg_opr64_reg64 rR13) (7 `op_Multiply` 16) Secret false scratch_b 7) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 676 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_AddLea64 (va_op_dst_opr64_reg64 rRdi) (va_op_opr64_reg64 rRdi) (va_const_opr64 96))
(va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 677 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc_last (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_xmm_xmm 5)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 678 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 5) (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 679 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store64_buffer128 (va_op_heaplet_mem_heaplet 3) (va_op_reg_opr64_reg64 rRbp)
(va_op_reg_opr64_reg64 rR12) (7 `op_Multiply` 16 + 8) Secret true scratch_b 7) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 680 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_AddLea64 (va_op_dst_opr64_reg64 rRsi) (va_op_opr64_reg64 rRsi) (va_const_opr64 96))
(va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 681 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 15)
(va_op_reg_opr64_reg64 rRcx) (0 - 128) Secret keys_b 0) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 683 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc_last (va_op_xmm_xmm 12) (va_op_xmm_xmm 12) (va_op_xmm_xmm 6)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 684 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 6) (va_op_xmm_xmm 5) (va_op_xmm_xmm 2)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 685 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc_last (va_op_xmm_xmm 13) (va_op_xmm_xmm 13) (va_op_xmm_xmm 7)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 686 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 7) (va_op_xmm_xmm 6) (va_op_xmm_xmm 2)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 687 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc_last (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_xmm_xmm 3)) (va_QBind
va_range1
"***** PRECONDITION NOT MET AT line 688 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPaddd (va_op_xmm_xmm 3) (va_op_xmm_xmm 7) (va_op_xmm_xmm 2)) (fun (va_s:va_state) _
-> let (va_arg117:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = round_keys in let
(va_arg116:Vale.Def.Types_s.quad32) = va_get_xmm 9 va_s in let
(va_arg115:Vale.Def.Types_s.quad32) = va_get_xmm 9 va_old_s in let
(va_arg114:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___1 #quad32 #quad32 #quad32
#quad32 #quad32 #quad32 init in let (va_arg113:Vale.Def.Types_s.quad32) =
__proj__Mktuple6__item___1 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 plain in let
(va_arg112:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___1 #quad32 #quad32 #quad32
#quad32 #quad32 #quad32 ctrs in let (va_arg111:Vale.AES.AES_common_s.algorithm) = alg in
va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 690 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.finish_cipher_opt va_arg111 va_arg112 va_arg113 va_arg114
va_arg115 va_arg116 va_arg117) (let (va_arg110:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) =
round_keys in let (va_arg109:Vale.Def.Types_s.quad32) = va_get_xmm 10 va_s in let
(va_arg108:Vale.Def.Types_s.quad32) = va_get_xmm 10 va_old_s in let
(va_arg107:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___2 #quad32 #quad32 #quad32
#quad32 #quad32 #quad32 init in let (va_arg106:Vale.Def.Types_s.quad32) =
__proj__Mktuple6__item___2 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 plain in let
(va_arg105:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___2 #quad32 #quad32 #quad32
#quad32 #quad32 #quad32 ctrs in let (va_arg104:Vale.AES.AES_common_s.algorithm) = alg in
va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 691 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.finish_cipher_opt va_arg104 va_arg105 va_arg106 va_arg107
va_arg108 va_arg109 va_arg110) (let (va_arg103:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) =
round_keys in let (va_arg102:Vale.Def.Types_s.quad32) = va_get_xmm 11 va_s in let
(va_arg101:Vale.Def.Types_s.quad32) = va_get_xmm 11 va_old_s in let
(va_arg100:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___3 #quad32 #quad32 #quad32
#quad32 #quad32 #quad32 init in let (va_arg99:Vale.Def.Types_s.quad32) =
__proj__Mktuple6__item___3 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 plain in let
(va_arg98:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___3 #quad32 #quad32 #quad32 #quad32
#quad32 #quad32 ctrs in let (va_arg97:Vale.AES.AES_common_s.algorithm) = alg in va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 692 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.finish_cipher_opt va_arg97 va_arg98 va_arg99 va_arg100
va_arg101 va_arg102 va_arg103) (let (va_arg96:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) =
round_keys in let (va_arg95:Vale.Def.Types_s.quad32) = va_get_xmm 12 va_s in let
(va_arg94:Vale.Def.Types_s.quad32) = va_get_xmm 12 va_old_s in let
(va_arg93:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___4 #quad32 #quad32 #quad32 #quad32
#quad32 #quad32 init in let (va_arg92:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___4
#quad32 #quad32 #quad32 #quad32 #quad32 #quad32 plain in let (va_arg91:Vale.Def.Types_s.quad32)
= __proj__Mktuple6__item___4 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs in let
(va_arg90:Vale.AES.AES_common_s.algorithm) = alg in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 693 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.finish_cipher_opt va_arg90 va_arg91 va_arg92 va_arg93
va_arg94 va_arg95 va_arg96) (let (va_arg89:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) =
round_keys in let (va_arg88:Vale.Def.Types_s.quad32) = va_get_xmm 13 va_s in let
(va_arg87:Vale.Def.Types_s.quad32) = va_get_xmm 13 va_old_s in let
(va_arg86:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___5 #quad32 #quad32 #quad32 #quad32
#quad32 #quad32 init in let (va_arg85:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___5
#quad32 #quad32 #quad32 #quad32 #quad32 #quad32 plain in let (va_arg84:Vale.Def.Types_s.quad32)
= __proj__Mktuple6__item___5 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs in let
(va_arg83:Vale.AES.AES_common_s.algorithm) = alg in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 694 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.finish_cipher_opt va_arg83 va_arg84 va_arg85 va_arg86
va_arg87 va_arg88 va_arg89) (let (va_arg82:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) =
round_keys in let (va_arg81:Vale.Def.Types_s.quad32) = va_get_xmm 14 va_s in let
(va_arg80:Vale.Def.Types_s.quad32) = va_get_xmm 14 va_old_s in let
(va_arg79:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___6 #quad32 #quad32 #quad32 #quad32
#quad32 #quad32 init in let (va_arg78:Vale.Def.Types_s.quad32) = __proj__Mktuple6__item___6
#quad32 #quad32 #quad32 #quad32 #quad32 #quad32 plain in let (va_arg77:Vale.Def.Types_s.quad32)
= __proj__Mktuple6__item___6 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs in let
(va_arg76:Vale.AES.AES_common_s.algorithm) = alg in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 695 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.finish_cipher_opt va_arg76 va_arg77 va_arg78 va_arg79
va_arg80 va_arg81 va_arg82) (va_QLemma va_range1
"***** PRECONDITION NOT MET AT line 696 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) -> Vale.AES.AES_s.is_aes_key_LE alg
key) alg (__proj__Mktuple6__item___1 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs)
key_words) (fun _ -> (fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) ->
Vale.AES.AES_s.aes_encrypt_LE alg key input_LE == Vale.AES.AES_s.eval_cipher alg input_LE
(Vale.AES.AES_s.key_to_round_keys_LE alg key)) alg (__proj__Mktuple6__item___1 #quad32 #quad32
#quad32 #quad32 #quad32 #quad32 ctrs) key_words) (fun (_:unit) -> finish_aes_encrypt_le alg
(__proj__Mktuple6__item___1 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs) key_words)
(va_QLemma va_range1
"***** PRECONDITION NOT MET AT line 697 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) -> Vale.AES.AES_s.is_aes_key_LE alg
key) alg (__proj__Mktuple6__item___2 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs)
key_words) (fun _ -> (fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) ->
Vale.AES.AES_s.aes_encrypt_LE alg key input_LE == Vale.AES.AES_s.eval_cipher alg input_LE
(Vale.AES.AES_s.key_to_round_keys_LE alg key)) alg (__proj__Mktuple6__item___2 #quad32 #quad32
#quad32 #quad32 #quad32 #quad32 ctrs) key_words) (fun (_:unit) -> finish_aes_encrypt_le alg
(__proj__Mktuple6__item___2 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs) key_words)
(va_QLemma va_range1
"***** PRECONDITION NOT MET AT line 698 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) -> Vale.AES.AES_s.is_aes_key_LE alg
key) alg (__proj__Mktuple6__item___3 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs)
key_words) (fun _ -> (fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) ->
Vale.AES.AES_s.aes_encrypt_LE alg key input_LE == Vale.AES.AES_s.eval_cipher alg input_LE
(Vale.AES.AES_s.key_to_round_keys_LE alg key)) alg (__proj__Mktuple6__item___3 #quad32 #quad32
#quad32 #quad32 #quad32 #quad32 ctrs) key_words) (fun (_:unit) -> finish_aes_encrypt_le alg
(__proj__Mktuple6__item___3 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs) key_words)
(va_QLemma va_range1
"***** PRECONDITION NOT MET AT line 699 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) -> Vale.AES.AES_s.is_aes_key_LE alg
key) alg (__proj__Mktuple6__item___4 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs)
key_words) (fun _ -> (fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) ->
Vale.AES.AES_s.aes_encrypt_LE alg key input_LE == Vale.AES.AES_s.eval_cipher alg input_LE
(Vale.AES.AES_s.key_to_round_keys_LE alg key)) alg (__proj__Mktuple6__item___4 #quad32 #quad32
#quad32 #quad32 #quad32 #quad32 ctrs) key_words) (fun (_:unit) -> finish_aes_encrypt_le alg
(__proj__Mktuple6__item___4 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs) key_words)
(va_QLemma va_range1
"***** PRECONDITION NOT MET AT line 700 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) -> Vale.AES.AES_s.is_aes_key_LE alg
key) alg (__proj__Mktuple6__item___5 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs)
key_words) (fun _ -> (fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) ->
Vale.AES.AES_s.aes_encrypt_LE alg key input_LE == Vale.AES.AES_s.eval_cipher alg input_LE
(Vale.AES.AES_s.key_to_round_keys_LE alg key)) alg (__proj__Mktuple6__item___5 #quad32 #quad32
#quad32 #quad32 #quad32 #quad32 ctrs) key_words) (fun (_:unit) -> finish_aes_encrypt_le alg
(__proj__Mktuple6__item___5 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs) key_words)
(va_QLemma va_range1
"***** PRECONDITION NOT MET AT line 701 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) -> Vale.AES.AES_s.is_aes_key_LE alg
key) alg (__proj__Mktuple6__item___6 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs)
key_words) (fun _ -> (fun (alg:algorithm) (input_LE:quad32) (key:(seq nat32)) ->
Vale.AES.AES_s.aes_encrypt_LE alg key input_LE == Vale.AES.AES_s.eval_cipher alg input_LE
(Vale.AES.AES_s.key_to_round_keys_LE alg key)) alg (__proj__Mktuple6__item___6 #quad32 #quad32
#quad32 #quad32 #quad32 #quad32 ctrs) key_words) (fun (_:unit) -> finish_aes_encrypt_le alg
(__proj__Mktuple6__item___6 #quad32 #quad32 #quad32 #quad32 #quad32 #quad32 ctrs) key_words)
(let (va_arg75:Vale.Def.Types_s.quad32) = Vale.X64.Decls.buffer128_read scratch_b 7
(va_get_mem_heaplet 3 va_s) in let (va_arg74:Vale.Def.Types_s.quad32) =
Vale.X64.Decls.buffer128_read scratch_b 7 (va_get_mem_heaplet 3 va_old_s) in let
(va_arg73:Vale.Def.Types_s.quad32) = inb in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 703 column 34 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.Arch.Types.lemma_reverse_bytes_quad32_64 va_arg73 va_arg74 va_arg75) (let
(va_arg72:Vale.Def.Types_s.quad32) = va_get_xmm 0 va_s in let
(va_arg71:Vale.Def.Types_s.quad32) = va_get_xmm 1 va_s in let
(va_arg70:Vale.Def.Types_s.quad32) = ctr_orig in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 705 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_incr_msb va_arg70 va_arg71 va_arg72 1) (let
(va_arg69:Vale.Def.Types_s.quad32) = va_get_xmm 5 va_s in let
(va_arg68:Vale.Def.Types_s.quad32) = va_get_xmm 1 va_s in let
(va_arg67:Vale.Def.Types_s.quad32) = ctr_orig in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 706 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_incr_msb va_arg67 va_arg68 va_arg69 2) (let
(va_arg66:Vale.Def.Types_s.quad32) = va_get_xmm 6 va_s in let
(va_arg65:Vale.Def.Types_s.quad32) = va_get_xmm 1 va_s in let
(va_arg64:Vale.Def.Types_s.quad32) = ctr_orig in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 707 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_incr_msb va_arg64 va_arg65 va_arg66 3) (let
(va_arg63:Vale.Def.Types_s.quad32) = va_get_xmm 7 va_s in let
(va_arg62:Vale.Def.Types_s.quad32) = va_get_xmm 1 va_s in let
(va_arg61:Vale.Def.Types_s.quad32) = ctr_orig in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 708 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_incr_msb va_arg61 va_arg62 va_arg63 4) (let
(va_arg60:Vale.Def.Types_s.quad32) = va_get_xmm 3 va_s in let
(va_arg59:Vale.Def.Types_s.quad32) = va_get_xmm 1 va_s in let
(va_arg58:Vale.Def.Types_s.quad32) = ctr_orig in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 709 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_incr_msb va_arg58 va_arg59 va_arg60 5) (va_QEmpty
(()))))))))))))))))))))))))))))))))))))))))
[@"opaque_to_smt"]
let va_lemma_Loop6x_final va_b0 va_s0 alg iv_b scratch_b key_words round_keys keys_b ctr_orig init
ctrs plain inb =
let (va_mods:va_mods_t) = [va_Mod_mem_heaplet 3; va_Mod_flags; va_Mod_xmm 15; va_Mod_xmm 14;
va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 7;
va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0;
va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_reg64 rR11; va_Mod_reg64 rRsi; va_Mod_reg64 rRdi;
va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_Loop6x_final va_mods alg iv_b scratch_b key_words round_keys keys_b ctr_orig
init ctrs plain inb in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_Loop6x_final alg) va_qc va_s0 (fun
va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 589 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_ok va_sM) /\ (label va_range1
"***** POSTCONDITION NOT MET AT line 649 column 72 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 scratch_b (va_get_mem_heaplet 3 va_s0)
(va_get_mem_heaplet 3 va_sM) 7 7) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 652 column 73 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 7 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 inb) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 654 column 111 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM, va_get_xmm
13 va_sM, va_get_xmm 14 va_sM) == map2_six_of #quad32 #quad32 #quad32 plain ctrs (fun
(p:quad32) (c:quad32) -> Vale.Def.Types_s.quad32_xor p (Vale.AES.AES_s.aes_encrypt_LE alg
key_words c))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 655 column 39 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_xmm 15 va_sM == FStar.Seq.Base.index #quad32 round_keys 0) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 657 column 33 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_reg64 rRdi va_sM == va_get_reg64 rRdi va_s0 + 96) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 658 column 33 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0 + 96) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 660 column 41 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_xmm 2 va_sM == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 16777216) /\ label
va_range1
"***** POSTCONDITION NOT MET AT line 662 column 55 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read scratch_b 8 (va_get_mem_heaplet 3 va_s0))
/\ label va_range1
"***** POSTCONDITION NOT MET AT line 663 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(let ctr = Vale.Def.Words_s.__proj__Mkfour__item__lo0 ctr_orig `op_Modulus` 256 in label
va_range1
"***** POSTCONDITION NOT MET AT line 665 column 60 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(ctr + 6 < 256 ==> (va_get_xmm 1 va_sM, va_get_xmm 0 va_sM, va_get_xmm 5 va_sM, va_get_xmm 6
va_sM, va_get_xmm 7 va_sM, va_get_xmm 3 va_sM) == xor_reverse_inc32lite_6 0 0 ctr_orig
(va_get_xmm 15 va_sM))))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_mem_heaplet 3; va_Mod_flags; va_Mod_xmm 15; va_Mod_xmm 14; va_Mod_xmm
13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 7; va_Mod_xmm 6;
va_Mod_xmm 5; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_reg64 rR13;
va_Mod_reg64 rR12; va_Mod_reg64 rR11; va_Mod_reg64 rRsi; va_Mod_reg64 rRdi; va_Mod_ok;
va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Loop6x_final alg iv_b scratch_b key_words round_keys keys_b ctr_orig init ctrs plain
inb va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Loop6x_final (va_code_Loop6x_final alg) va_s0 alg iv_b scratch_b
key_words round_keys keys_b ctr_orig init ctrs plain inb in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_mem_heaplet 3 va_sM (va_update_flags va_sM (va_update_xmm 15
va_sM (va_update_xmm 14 va_sM (va_update_xmm 13 va_sM (va_update_xmm 12 va_sM (va_update_xmm 11
va_sM (va_update_xmm 10 va_sM (va_update_xmm 9 va_sM (va_update_xmm 7 va_sM (va_update_xmm 6
va_sM (va_update_xmm 5 va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1
va_sM (va_update_xmm 0 va_sM (va_update_reg64 rR13 va_sM (va_update_reg64 rR12 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdi va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))));
va_lemma_norm_mods ([va_Mod_mem_heaplet 3; va_Mod_flags; va_Mod_xmm 15; va_Mod_xmm 14; va_Mod_xmm
13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 7; va_Mod_xmm 6;
va_Mod_xmm 5; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_reg64 rR13;
va_Mod_reg64 rR12; va_Mod_reg64 rR11; va_Mod_reg64 rRsi; va_Mod_reg64 rRdi; va_Mod_mem]) va_sM
va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Loop6x_save_output
[@ "opaque_to_smt" va_qattr]
let va_code_Loop6x_save_output () =
(va_Block (va_CCons (va_code_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64
rRsi) (va_op_xmm_xmm 9) (0 - 96) Secret) (va_CCons (va_code_VPxor (va_op_xmm_xmm 9)
(va_op_xmm_xmm 1) (va_op_opr128_xmm 15)) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi) (va_op_xmm_xmm 10) (0 - 80) Secret)
(va_CCons (va_code_Mov128 (va_op_xmm_xmm 10) (va_op_xmm_xmm 0)) (va_CCons
(va_code_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi)
(va_op_xmm_xmm 11) (0 - 64) Secret) (va_CCons (va_code_Mov128 (va_op_xmm_xmm 11) (va_op_xmm_xmm
5)) (va_CCons (va_code_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64
rRsi) (va_op_xmm_xmm 12) (0 - 48) Secret) (va_CCons (va_code_Mov128 (va_op_xmm_xmm 12)
(va_op_xmm_xmm 6)) (va_CCons (va_code_Store128_buffer (va_op_heaplet_mem_heaplet 6)
(va_op_reg_opr64_reg64 rRsi) (va_op_xmm_xmm 13) (0 - 32) Secret) (va_CCons (va_code_Mov128
(va_op_xmm_xmm 13) (va_op_xmm_xmm 7)) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi) (va_op_xmm_xmm 14) (0 - 16) Secret)
(va_CCons (va_code_Mov128 (va_op_xmm_xmm 14) (va_op_xmm_xmm 3)) (va_CNil ()))))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_Loop6x_save_output () =
(va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 6)
(va_op_reg_opr64_reg64 rRsi) (va_op_xmm_xmm 9) (0 - 96) Secret) (va_pbool_and
(va_codegen_success_VPxor (va_op_xmm_xmm 9) (va_op_xmm_xmm 1) (va_op_opr128_xmm 15))
(va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 6)
(va_op_reg_opr64_reg64 rRsi) (va_op_xmm_xmm 10) (0 - 80) Secret) (va_pbool_and
(va_codegen_success_Mov128 (va_op_xmm_xmm 10) (va_op_xmm_xmm 0)) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi)
(va_op_xmm_xmm 11) (0 - 64) Secret) (va_pbool_and (va_codegen_success_Mov128 (va_op_xmm_xmm 11)
(va_op_xmm_xmm 5)) (va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet
6) (va_op_reg_opr64_reg64 rRsi) (va_op_xmm_xmm 12) (0 - 48) Secret) (va_pbool_and
(va_codegen_success_Mov128 (va_op_xmm_xmm 12) (va_op_xmm_xmm 6)) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi)
(va_op_xmm_xmm 13) (0 - 32) Secret) (va_pbool_and (va_codegen_success_Mov128 (va_op_xmm_xmm 13)
(va_op_xmm_xmm 7)) (va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet
6) (va_op_reg_opr64_reg64 rRsi) (va_op_xmm_xmm 14) (0 - 16) Secret) (va_pbool_and
(va_codegen_success_Mov128 (va_op_xmm_xmm 14) (va_op_xmm_xmm 3)) (va_ttrue ())))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_Loop6x_save_output (va_mods:va_mods_t) (count:nat) (out_b:buffer128) : (va_quickCode
unit (va_code_Loop6x_save_output ())) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 744 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi)
(va_op_xmm_xmm 9) (0 - 96) Secret out_b (count `op_Multiply` 6 + 0)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 745 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VPxor (va_op_xmm_xmm 9) (va_op_xmm_xmm 1) (va_op_opr128_xmm 15)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 746 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi)
(va_op_xmm_xmm 10) (0 - 80) Secret out_b (count `op_Multiply` 6 + 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 747 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mov128 (va_op_xmm_xmm 10) (va_op_xmm_xmm 0)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 748 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi)
(va_op_xmm_xmm 11) (0 - 64) Secret out_b (count `op_Multiply` 6 + 2)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 749 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mov128 (va_op_xmm_xmm 11) (va_op_xmm_xmm 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 750 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi)
(va_op_xmm_xmm 12) (0 - 48) Secret out_b (count `op_Multiply` 6 + 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 751 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mov128 (va_op_xmm_xmm 12) (va_op_xmm_xmm 6)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 752 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi)
(va_op_xmm_xmm 13) (0 - 32) Secret out_b (count `op_Multiply` 6 + 4)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 753 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mov128 (va_op_xmm_xmm 13) (va_op_xmm_xmm 7)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 754 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rRsi)
(va_op_xmm_xmm 14) (0 - 16) Secret out_b (count `op_Multiply` 6 + 5)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 755 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Mov128 (va_op_xmm_xmm 14) (va_op_xmm_xmm 3)) (va_QEmpty (())))))))))))))))
[@"opaque_to_smt"]
let va_lemma_Loop6x_save_output va_b0 va_s0 count out_b =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_mem_heaplet 6; va_Mod_xmm 14; va_Mod_xmm 13;
va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_Loop6x_save_output va_mods count out_b in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_Loop6x_save_output ()) va_qc va_s0 (fun
va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 712 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_ok va_sM) /\ (label va_range1
"***** POSTCONDITION NOT MET AT line 737 column 84 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 out_b (va_get_mem_heaplet 6 va_s0)
(va_get_mem_heaplet 6 va_sM) (count `op_Multiply` 6 + 0) (count `op_Multiply` 6 + 5)) /\ label
va_range1
"***** POSTCONDITION NOT MET AT line 738 column 120 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(FStar.Seq.Base.slice #Vale.X64.Decls.quad32 (Vale.X64.Decls.buffer128_as_seq
(va_get_mem_heaplet 6 va_sM) out_b) 0 (6 `op_Multiply` count) == FStar.Seq.Base.slice
#Vale.X64.Decls.quad32 (Vale.X64.Decls.buffer128_as_seq (va_get_mem_heaplet 6 va_s0) out_b) 0
(6 `op_Multiply` count)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 740 column 92 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((va_get_xmm 9 va_s0, va_get_xmm 10 va_s0, va_get_xmm 11 va_s0, va_get_xmm 12 va_s0, va_get_xmm
13 va_s0, va_get_xmm 14 va_s0) == make_six_of #quad32 (fun (i:(va_int_range 0 5)) ->
Vale.X64.Decls.buffer128_read out_b (count `op_Multiply` 6 + i) (va_get_mem_heaplet 6 va_sM)))
/\ label va_range1
"***** POSTCONDITION NOT MET AT line 742 column 64 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((va_get_xmm 9 va_sM, va_get_xmm 10 va_sM, va_get_xmm 11 va_sM, va_get_xmm 12 va_sM, va_get_xmm
13 va_sM, va_get_xmm 14 va_sM) == (Vale.Def.Types_s.quad32_xor (va_get_xmm 1 va_sM) (va_get_xmm
15 va_sM), va_get_xmm 0 va_sM, va_get_xmm 5 va_sM, va_get_xmm 6 va_sM, va_get_xmm 7 va_sM,
va_get_xmm 3 va_sM)))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_mem_heaplet 6; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm
12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Loop6x_save_output count out_b va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Loop6x_save_output (va_code_Loop6x_save_output ()) va_s0 count
out_b in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet 6 va_sM (va_update_xmm 14
va_sM (va_update_xmm 13 va_sM (va_update_xmm 12 va_sM (va_update_xmm 11 va_sM (va_update_xmm 10
va_sM (va_update_xmm 9 va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_mem_heaplet 6; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm
12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Loop6x_partial
#push-options "--z3rlimit 50 --max_ifuel 0"
[@ "opaque_to_smt" va_qattr]
let va_code_untransformedoriginal_Loop6x_partial alg =
(va_Block (va_CCons (va_code_Loop6x_preamble alg) (va_CCons (va_code_Loop6x_plain alg 0
(va_op_xmm_xmm 2)) (va_CCons (va_code_MulAdd_step 0 0 (va_op_xmm_xmm 1) (va_op_xmm_xmm 5)
(va_op_xmm_xmm 6) (va_op_xmm_xmm 7) (va_op_xmm_xmm 7) (va_op_xmm_xmm 3)) (va_CCons
(va_code_MulAdd_step 1 1 (va_op_xmm_xmm 5) (va_op_xmm_xmm 1) (va_op_xmm_xmm 2) (va_op_xmm_xmm
3) (va_op_xmm_xmm 0) (va_op_xmm_xmm 3)) (va_CCons (va_code_Loop6x_plain alg 1 (va_op_xmm_xmm
15)) (va_CCons (va_code_Loop6x_reverse128 5 2) (va_CCons (va_code_MulAdd_step 2 3
(va_op_xmm_xmm 1) (va_op_xmm_xmm 2) (va_op_xmm_xmm 3) (va_op_xmm_xmm 5) (va_op_xmm_xmm 0)
(va_op_xmm_xmm 5)) (va_CCons (va_code_Loop6x_plain alg 2 (va_op_xmm_xmm 15)) (va_CCons
(va_code_MulAdd_step 3 4 (va_op_xmm_xmm 2) (va_op_xmm_xmm 3) (va_op_xmm_xmm 5) (va_op_xmm_xmm
1) (va_op_xmm_xmm 0) (va_op_xmm_xmm 1)) (va_CCons (va_code_Loop6x_plain alg 3 (va_op_xmm_xmm
15)) (va_CCons (va_code_Loop6x_reverse128 4 3) (va_CCons (va_code_MulAdd_step 4 6
(va_op_xmm_xmm 3) (va_op_xmm_xmm 5) (va_op_xmm_xmm 1) (va_op_xmm_xmm 2) (va_op_xmm_xmm 0)
(va_op_xmm_xmm 2)) (va_CCons (va_code_Loop6x_plain alg 4 (va_op_xmm_xmm 15)) (va_CCons
(va_code_Loop6x_reverse128 3 4) (va_CCons (va_code_MulAdd_step 5 7 (va_op_xmm_xmm 2)
(va_op_xmm_xmm 5) (va_op_xmm_xmm 1) (va_op_xmm_xmm 8) (va_op_xmm_xmm 8) (va_op_xmm_xmm 3))
(va_CCons (va_code_Loop6x_plain alg 5 (va_op_xmm_xmm 15)) (va_CCons (va_code_Loop6x_reverse128
2 5) (va_CCons (va_code_Load_0xc2_msb (va_op_xmm_xmm 3)) (va_CCons (va_code_ReduceLast false)
(va_CCons (va_code_Loop6x_plain alg 6 (va_op_xmm_xmm 15)) (va_CCons (va_code_Loop6x_reverse128
1 6) (va_CCons (va_code_Loop6x_plain alg 7 (va_op_xmm_xmm 1)) (va_CCons
(va_code_LoadBe64_buffer128 (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rR13)
(va_op_reg_opr64_reg64 rR14) (0 `op_Multiply` 16 + 8) Secret true) (va_CCons
(va_code_LoadBe64_buffer128 (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rR12)
(va_op_reg_opr64_reg64 rR14) (0 `op_Multiply` 16) Secret false) (va_CCons (va_code_Loop6x_plain
alg 8 (va_op_xmm_xmm 15)) (va_CCons (if (alg = AES_256) then va_Block (va_CCons
(va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRcx) (160 - 128) Secret) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 9) (va_op_xmm_xmm 9)
(va_op_xmm_xmm 1)) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 10) (va_op_xmm_xmm 10)
(va_op_xmm_xmm 1)) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 11) (va_op_xmm_xmm 11)
(va_op_xmm_xmm 1)) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 12) (va_op_xmm_xmm 12)
(va_op_xmm_xmm 1)) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 13) (va_op_xmm_xmm 13)
(va_op_xmm_xmm 1)) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 14) (va_op_xmm_xmm 14)
(va_op_xmm_xmm 1)) (va_CCons (va_code_Loop6x_plain alg 10 (va_op_xmm_xmm 15)) (va_CCons
(va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRcx) (192 - 128) Secret) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 9) (va_op_xmm_xmm 9)
(va_op_xmm_xmm 1)) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 10) (va_op_xmm_xmm 10)
(va_op_xmm_xmm 1)) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 11) (va_op_xmm_xmm 11)
(va_op_xmm_xmm 1)) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 12) (va_op_xmm_xmm 12)
(va_op_xmm_xmm 1)) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 13) (va_op_xmm_xmm 13)
(va_op_xmm_xmm 1)) (va_CCons (va_code_VAESNI_enc (va_op_xmm_xmm 14) (va_op_xmm_xmm 14)
(va_op_xmm_xmm 1)) (va_CCons (va_code_Loop6x_plain alg 12 (va_op_xmm_xmm 15)) (va_CNil
()))))))))))))))))) else va_Block (va_CNil ())) (va_CCons (if (alg = AES_256) then va_Block
(va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1)
(va_op_reg_opr64_reg64 rRcx) (224 - 128) Secret) (va_CNil ())) else va_Block (va_CCons
(va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRcx) (160 - 128) Secret) (va_CNil ()))) (va_CCons (va_code_Loop6x_round9 alg) (va_CNil
()))))))))))))))))))))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_untransformedoriginal_Loop6x_partial alg =
(va_pbool_and (va_codegen_success_Loop6x_preamble alg) (va_pbool_and
(va_codegen_success_Loop6x_plain alg 0 (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_MulAdd_step 0 0 (va_op_xmm_xmm 1) (va_op_xmm_xmm 5) (va_op_xmm_xmm 6)
(va_op_xmm_xmm 7) (va_op_xmm_xmm 7) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_MulAdd_step 1 1 (va_op_xmm_xmm 5) (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)
(va_op_xmm_xmm 3) (va_op_xmm_xmm 0) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_Loop6x_plain alg 1 (va_op_xmm_xmm 15)) (va_pbool_and
(va_codegen_success_Loop6x_reverse128 5 2) (va_pbool_and (va_codegen_success_MulAdd_step 2 3
(va_op_xmm_xmm 1) (va_op_xmm_xmm 2) (va_op_xmm_xmm 3) (va_op_xmm_xmm 5) (va_op_xmm_xmm 0)
(va_op_xmm_xmm 5)) (va_pbool_and (va_codegen_success_Loop6x_plain alg 2 (va_op_xmm_xmm 15))
(va_pbool_and (va_codegen_success_MulAdd_step 3 4 (va_op_xmm_xmm 2) (va_op_xmm_xmm 3)
(va_op_xmm_xmm 5) (va_op_xmm_xmm 1) (va_op_xmm_xmm 0) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Loop6x_plain alg 3 (va_op_xmm_xmm 15)) (va_pbool_and
(va_codegen_success_Loop6x_reverse128 4 3) (va_pbool_and (va_codegen_success_MulAdd_step 4 6
(va_op_xmm_xmm 3) (va_op_xmm_xmm 5) (va_op_xmm_xmm 1) (va_op_xmm_xmm 2) (va_op_xmm_xmm 0)
(va_op_xmm_xmm 2)) (va_pbool_and (va_codegen_success_Loop6x_plain alg 4 (va_op_xmm_xmm 15))
(va_pbool_and (va_codegen_success_Loop6x_reverse128 3 4) (va_pbool_and
(va_codegen_success_MulAdd_step 5 7 (va_op_xmm_xmm 2) (va_op_xmm_xmm 5) (va_op_xmm_xmm 1)
(va_op_xmm_xmm 8) (va_op_xmm_xmm 8) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_Loop6x_plain alg 5 (va_op_xmm_xmm 15)) (va_pbool_and
(va_codegen_success_Loop6x_reverse128 2 5) (va_pbool_and (va_codegen_success_Load_0xc2_msb
(va_op_xmm_xmm 3)) (va_pbool_and (va_codegen_success_ReduceLast false) (va_pbool_and
(va_codegen_success_Loop6x_plain alg 6 (va_op_xmm_xmm 15)) (va_pbool_and
(va_codegen_success_Loop6x_reverse128 1 6) (va_pbool_and (va_codegen_success_Loop6x_plain alg 7
(va_op_xmm_xmm 1)) (va_pbool_and (va_codegen_success_LoadBe64_buffer128
(va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rR13) (va_op_reg_opr64_reg64 rR14) (0
`op_Multiply` 16 + 8) Secret true) (va_pbool_and (va_codegen_success_LoadBe64_buffer128
(va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rR12) (va_op_reg_opr64_reg64 rR14) (0
`op_Multiply` 16) Secret false) (va_pbool_and (va_codegen_success_Loop6x_plain alg 8
(va_op_xmm_xmm 15)) (va_pbool_and (if (alg = AES_256) then va_pbool_and
(va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1)
(va_op_reg_opr64_reg64 rRcx) (160 - 128) Secret) (va_pbool_and (va_codegen_success_VAESNI_enc
(va_op_xmm_xmm 9) (va_op_xmm_xmm 9) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_VAESNI_enc (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_xmm_xmm 1))
(va_pbool_and (va_codegen_success_VAESNI_enc (va_op_xmm_xmm 11) (va_op_xmm_xmm 11)
(va_op_xmm_xmm 1)) (va_pbool_and (va_codegen_success_VAESNI_enc (va_op_xmm_xmm 12)
(va_op_xmm_xmm 12) (va_op_xmm_xmm 1)) (va_pbool_and (va_codegen_success_VAESNI_enc
(va_op_xmm_xmm 13) (va_op_xmm_xmm 13) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_VAESNI_enc (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_xmm_xmm 1))
(va_pbool_and (va_codegen_success_Loop6x_plain alg 10 (va_op_xmm_xmm 15)) (va_pbool_and
(va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1)
(va_op_reg_opr64_reg64 rRcx) (192 - 128) Secret) (va_pbool_and (va_codegen_success_VAESNI_enc
(va_op_xmm_xmm 9) (va_op_xmm_xmm 9) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_VAESNI_enc (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_xmm_xmm 1))
(va_pbool_and (va_codegen_success_VAESNI_enc (va_op_xmm_xmm 11) (va_op_xmm_xmm 11)
(va_op_xmm_xmm 1)) (va_pbool_and (va_codegen_success_VAESNI_enc (va_op_xmm_xmm 12)
(va_op_xmm_xmm 12) (va_op_xmm_xmm 1)) (va_pbool_and (va_codegen_success_VAESNI_enc
(va_op_xmm_xmm 13) (va_op_xmm_xmm 13) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_VAESNI_enc (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_xmm_xmm 1))
(va_pbool_and (va_codegen_success_Loop6x_plain alg 12 (va_op_xmm_xmm 15)) (va_ttrue
())))))))))))))))) else va_ttrue ()) (va_pbool_and (if (alg = AES_256) then va_pbool_and
(va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1)
(va_op_reg_opr64_reg64 rRcx) (224 - 128) Secret) (va_ttrue ()) else va_pbool_and
(va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1)
(va_op_reg_opr64_reg64 rRcx) (160 - 128) Secret) (va_ttrue ())) (va_pbool_and
(va_codegen_success_Loop6x_round9 alg) (va_ttrue ())))))))))))))))))))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_untransformedoriginal_Loop6x_partial (va_mods:va_mods_t) (alg:algorithm) (h_LE:quad32)
(y_prev:quad32) (data:(seq quad32)) (count:nat) (in0_count:nat) (iv_b:buffer128)
(in0_b:buffer128) (in_b:buffer128) (scratch_b:buffer128) (key_words:(seq nat32)) (round_keys:(seq
quad32)) (keys_b:buffer128) (hkeys_b:buffer128) (ctr_BE:quad32) : (va_quickCode (quad32_6)
(va_code_untransformedoriginal_Loop6x_partial alg)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in let
(h:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
(Vale.Def.Types_s.reverse_bytes_quad32 h_LE) in let (prev:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (Vale.Def.Types_s.reverse_bytes_quad32 y_prev) in let
(init:quad32_6) = make_six_of #Vale.Def.Types_s.quad32 (fun (n:(va_int_range 0 5)) ->
Vale.Def.Types_s.quad32_xor (Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite
ctr_BE n)) (va_get_xmm 15 va_s)) in let (start:(va_int_at_least 0)) = in0_count `op_Multiply` 6
in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 871 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_preamble alg h_LE iv_b scratch_b key_words round_keys keys_b hkeys_b ctr_BE)
(va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 872 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 0 key_words round_keys keys_b init (va_op_xmm_xmm 2)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 873 column 16 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_MulAdd_step 0 0 (va_op_xmm_xmm 1) (va_op_xmm_xmm 5) (va_op_xmm_xmm 6) (va_op_xmm_xmm
7) (va_op_xmm_xmm 7) (va_op_xmm_xmm 3) hkeys_b scratch_b h prev data) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 874 column 16 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_MulAdd_step 1 1 (va_op_xmm_xmm 5) (va_op_xmm_xmm 1) (va_op_xmm_xmm 2) (va_op_xmm_xmm
3) (va_op_xmm_xmm 0) (va_op_xmm_xmm 3) hkeys_b scratch_b h prev data) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 875 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 1 key_words round_keys keys_b init (va_op_xmm_xmm 15)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 876 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_reverse128 5 2 start in0_b scratch_b) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 877 column 16 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_MulAdd_step 2 3 (va_op_xmm_xmm 1) (va_op_xmm_xmm 2) (va_op_xmm_xmm 3) (va_op_xmm_xmm
5) (va_op_xmm_xmm 0) (va_op_xmm_xmm 5) hkeys_b scratch_b h prev data) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 878 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 2 key_words round_keys keys_b init (va_op_xmm_xmm 15)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 879 column 16 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_MulAdd_step 3 4 (va_op_xmm_xmm 2) (va_op_xmm_xmm 3) (va_op_xmm_xmm 5) (va_op_xmm_xmm
1) (va_op_xmm_xmm 0) (va_op_xmm_xmm 1) hkeys_b scratch_b h prev data) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 880 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 3 key_words round_keys keys_b init (va_op_xmm_xmm 15)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 881 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_reverse128 4 3 start in0_b scratch_b) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 882 column 16 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_MulAdd_step 4 6 (va_op_xmm_xmm 3) (va_op_xmm_xmm 5) (va_op_xmm_xmm 1) (va_op_xmm_xmm
2) (va_op_xmm_xmm 0) (va_op_xmm_xmm 2) hkeys_b scratch_b h prev data) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 883 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 4 key_words round_keys keys_b init (va_op_xmm_xmm 15)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 884 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_reverse128 3 4 start in0_b scratch_b) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 885 column 16 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_MulAdd_step 5 7 (va_op_xmm_xmm 2) (va_op_xmm_xmm 5) (va_op_xmm_xmm 1) (va_op_xmm_xmm
8) (va_op_xmm_xmm 8) (va_op_xmm_xmm 3) hkeys_b scratch_b h prev data) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 886 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 5 key_words round_keys keys_b init (va_op_xmm_xmm 15)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 887 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_reverse128 2 5 start in0_b scratch_b) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 888 column 18 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load_0xc2_msb (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 891 column 15 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_ReduceLast false h_LE y_prev data) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 892 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 6 key_words round_keys keys_b init (va_op_xmm_xmm 15)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 893 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_reverse128 1 6 start in0_b scratch_b) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 894 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 7 key_words round_keys keys_b init (va_op_xmm_xmm 1)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 895 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_LoadBe64_buffer128 (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rR13)
(va_op_reg_opr64_reg64 rR14) (0 `op_Multiply` 16 + 8) Secret true in0_b (in0_count
`op_Multiply` 6 + 0)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 896 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_LoadBe64_buffer128 (va_op_heaplet_mem_heaplet 6) (va_op_reg_opr64_reg64 rR12)
(va_op_reg_opr64_reg64 rR14) (0 `op_Multiply` 16) Secret false in0_b (in0_count `op_Multiply` 6
+ 0)) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 897 column 17 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 8 key_words round_keys keys_b init (va_op_xmm_xmm 15)) (fun
(va_s:va_state) _ -> va_QBind va_range1
"***** PRECONDITION NOT MET AT line 901 column 15 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_qInlineIf va_mods (alg = AES_256) (qblock va_mods (fun (va_s:va_state) -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 913 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRcx) (160 - 128) Secret keys_b 10) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 914 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 9) (va_op_xmm_xmm 9) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 915 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_xmm_xmm 1)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 916 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_xmm_xmm 1)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 917 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 12) (va_op_xmm_xmm 12) (va_op_xmm_xmm 1)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 918 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 13) (va_op_xmm_xmm 13) (va_op_xmm_xmm 1)) (va_QBind
va_range1
"***** PRECONDITION NOT MET AT line 919 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_xmm_xmm 1)) (fun
(va_s:va_state) _ -> va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 921 column 27 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_s.eval_rounds_reveal ()) (va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 922 column 44 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.commute_sub_bytes_shift_rows_forall ()) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 923 column 21 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 10 key_words round_keys keys_b init (va_op_xmm_xmm 15)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 926 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRcx) (192 - 128) Secret keys_b 12) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 927 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 9) (va_op_xmm_xmm 9) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 928 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 10) (va_op_xmm_xmm 10) (va_op_xmm_xmm 1)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 929 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 11) (va_op_xmm_xmm 11) (va_op_xmm_xmm 1)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 930 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 12) (va_op_xmm_xmm 12) (va_op_xmm_xmm 1)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 931 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 13) (va_op_xmm_xmm 13) (va_op_xmm_xmm 1)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 932 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_VAESNI_enc (va_op_xmm_xmm 14) (va_op_xmm_xmm 14) (va_op_xmm_xmm 1)) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 934 column 21 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_plain alg 12 key_words round_keys keys_b init (va_op_xmm_xmm 15)) (va_QEmpty
(()))))))))))))))))))))) (qblock va_mods (fun (va_s:va_state) -> va_QEmpty (())))) (fun
(va_s:va_state) va_g -> va_QBind va_range1
"***** PRECONDITION NOT MET AT line 937 column 15 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_qInlineIf va_mods (alg = AES_256) (qblock va_mods (fun (va_s:va_state) -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 939 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRcx) (224 - 128) Secret keys_b 14) (va_QEmpty (())))) (qblock va_mods (fun (va_s:va_state) ->
va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 943 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRcx) (160 - 128) Secret keys_b 10) (va_QEmpty (()))))) (fun (va_s:va_state) va_g -> va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 946 column 18 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_quick_Loop6x_round9 alg count in_b scratch_b key_words round_keys keys_b) (va_QEmpty
((init)))))))))))))))))))))))))))))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.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.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Transformers.Transform.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.AES.X64.PolyOps.fsti.checked",
"Vale.AES.X64.AESopt2.fsti.checked",
"Vale.AES.X64.AESGCM_expected_code.fsti.checked",
"Vale.AES.GHash.fsti.checked",
"Vale.AES.GF128_s.fsti.checked",
"Vale.AES.GF128.fsti.checked",
"Vale.AES.GCTR_s.fst.checked",
"Vale.AES.GCTR.fsti.checked",
"Vale.AES.GCM_helpers.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.AES.X64.AESopt.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Transform",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64.AESGCM_expected_code",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64.AESopt2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64.PolyOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GHash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCM_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"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.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"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.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_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": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Transform",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64.AESGCM_expected_code",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64.AESopt2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64.PolyOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GHash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCM_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"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.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"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.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_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": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"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": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
alg: Vale.AES.AES_common_s.algorithm ->
h_LE: Vale.X64.Decls.quad32 ->
y_prev: Vale.X64.Decls.quad32 ->
data: FStar.Seq.Base.seq Vale.X64.Decls.quad32 ->
count: Prims.nat ->
in0_count: Prims.nat ->
iv_b: Vale.X64.Memory.buffer128 ->
in0_b: Vale.X64.Memory.buffer128 ->
in_b: Vale.X64.Memory.buffer128 ->
scratch_b: Vale.X64.Memory.buffer128 ->
key_words: FStar.Seq.Base.seq Vale.X64.Memory.nat32 ->
round_keys: FStar.Seq.Base.seq Vale.X64.Decls.quad32 ->
keys_b: Vale.X64.Memory.buffer128 ->
hkeys_b: Vale.X64.Memory.buffer128 ->
ctr_BE: Vale.X64.Decls.quad32
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Vale.AES.X64.AESopt.quad32_6) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.AES.AES_common_s.algorithm",
"Vale.X64.Decls.quad32",
"FStar.Seq.Base.seq",
"Prims.nat",
"Vale.X64.Memory.buffer128",
"Vale.X64.Memory.nat32",
"Vale.X64.QuickCodes.fuel",
"Vale.AES.X64.AESopt.quad32_6",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.Decls.va_fuel",
"Prims.unit",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"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_xmm",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR12",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.QuickCode.va_Mod_ok",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.list",
"Vale.X64.QuickCode.__proj__QProc__item__mods",
"Vale.AES.X64.AESopt.va_code_untransformedoriginal_Loop6x_partial",
"FStar.Pervasives.Native.tuple3",
"Vale.X64.State.vale_state",
"Vale.X64.QuickCodes.va_wp_sound_code_norm",
"Prims.l_and",
"Vale.X64.QuickCodes.label",
"Vale.X64.QuickCodes.va_range1",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.Decls.modifies_buffer_specific128",
"Vale.X64.Decls.va_get_mem_heaplet",
"Prims.op_LessThanOrEqual",
"Vale.X64.Decls.va_get_reg64",
"Prims.op_LessThan",
"Prims.int",
"Prims.op_Modulus",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.Def.Types_s.nat32",
"Vale.AES.GCTR.inc32lite",
"FStar.Pervasives.Native.tuple6",
"FStar.Pervasives.Native.Mktuple6",
"Vale.X64.Decls.va_get_xmm",
"Vale.AES.X64.AESopt.rounds_opaque_6",
"Prims.op_Subtraction",
"Vale.AES.AES_common_s.nr",
"Vale.Def.Types_s.nat64",
"Vale.Def.Types_s.reverse_bytes_nat64",
"Vale.Arch.Types.hi64",
"Vale.X64.Decls.buffer128_read",
"Prims.op_Addition",
"Prims.op_Multiply",
"Vale.Arch.Types.lo64",
"Vale.AES.X64.AESopt.make_six_of",
"Vale.X64.Decls.va_int_range",
"Vale.Def.Types_s.quad32_xor",
"Vale.Def.Types_s.quad32",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Vale.AES.X64.AESopt.six_of",
"FStar.Seq.Base.index",
"Vale.Math.Poly2_s.poly",
"Vale.Math.Poly2.Bits_s.of_quad32",
"Vale.AES.GHash.ghash_incremental",
"Vale.AES.X64.AESopt.add",
"Vale.X64.QuickCode.quickCode",
"Vale.AES.X64.AESopt.va_qcode_untransformedoriginal_Loop6x_partial"
] | [] | false | false | false | false | false | let va_lemma_untransformedoriginal_Loop6x_partial
va_b0
va_s0
alg
h_LE
y_prev
data
count
in0_count
iv_b
in0_b
in_b
scratch_b
key_words
round_keys
keys_b
hkeys_b
ctr_BE
=
| let va_mods:va_mods_t =
[
va_Mod_flags; va_Mod_mem_heaplet 3; va_Mod_mem_heaplet 2; va_Mod_xmm 15; va_Mod_xmm 14;
va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 8;
va_Mod_xmm 7; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 4; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_xmm 0; va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_reg64 rR11; va_Mod_reg64 rRbx;
va_Mod_ok; va_Mod_mem
]
in
let va_qc =
va_qcode_untransformedoriginal_Loop6x_partial va_mods alg h_LE y_prev data count in0_count iv_b
in0_b in_b scratch_b key_words round_keys keys_b hkeys_b ctr_BE
in
let va_sM, va_fM, va_g =
va_wp_sound_code_norm (va_code_untransformedoriginal_Loop6x_partial alg)
va_qc
va_s0
(fun va_s0 va_sM va_g ->
let init = va_g in
label va_range1
"***** POSTCONDITION NOT MET AT line 758 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_ok va_sM) /\
(let h:Vale.Math.Poly2_s.poly =
Vale.Math.Poly2.Bits_s.of_quad32 (Vale.Def.Types_s.reverse_bytes_quad32 h_LE)
in
let prev:Vale.Math.Poly2_s.poly =
Vale.Math.Poly2.Bits_s.of_quad32 (Vale.Def.Types_s.reverse_bytes_quad32 y_prev)
in
label va_range1
"***** POSTCONDITION NOT MET AT line 837 column 72 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 scratch_b
(va_get_mem_heaplet 3 va_s0)
(va_get_mem_heaplet 3 va_sM)
1
8) /\
label va_range1
"***** POSTCONDITION NOT MET AT line 838 column 70 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 iv_b
(va_get_mem_heaplet 2 va_s0)
(va_get_mem_heaplet 2 va_sM)
0
0) /\
label va_range1
"***** POSTCONDITION NOT MET AT line 843 column 27 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(0 <= va_get_reg64 rRbx va_sM /\ va_get_reg64 rRbx va_sM < 256) /\
label va_range1
"***** POSTCONDITION NOT MET AT line 844 column 50 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_reg64 rRbx va_sM ==
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (Vale.AES.GCTR.inc32lite ctr_BE 6))
`op_Modulus`
256) /\
label va_range1
"***** POSTCONDITION NOT MET AT line 847 column 118 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((va_get_xmm 9 va_sM,
va_get_xmm 10 va_sM,
va_get_xmm 11 va_sM,
va_get_xmm 12 va_sM,
va_get_xmm 13 va_sM,
va_get_xmm 14 va_sM) ==
rounds_opaque_6 init round_keys (Vale.AES.AES_common_s.nr alg - 1)) /\
label va_range1
"***** POSTCONDITION NOT MET AT line 848 column 90 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_reg64 rR13 va_sM ==
Vale.Def.Types_s.reverse_bytes_nat64 (Vale.Arch.Types.hi64 (Vale.X64.Decls.buffer128_read
in0_b
(in0_count `op_Multiply` 6 + 0)
(va_get_mem_heaplet 6 va_sM)))) /\
label va_range1
"***** POSTCONDITION NOT MET AT line 849 column 90 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(va_get_reg64 rR12 va_sM ==
Vale.Def.Types_s.reverse_bytes_nat64 (Vale.Arch.Types.lo64 (Vale.X64.Decls.buffer128_read
in0_b
(in0_count `op_Multiply` 6 + 0)
(va_get_mem_heaplet 6 va_sM)))) /\
label va_range1
"***** POSTCONDITION NOT MET AT line 850 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(let rk = FStar.Seq.Base.index #quad32 round_keys (Vale.AES.AES_common_s.nr alg) in
label va_range1
"***** POSTCONDITION NOT MET AT line 852 column 107 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
((va_get_xmm 2 va_sM,
va_get_xmm 0 va_sM,
va_get_xmm 5 va_sM,
va_get_xmm 6 va_sM,
va_get_xmm 7 va_sM,
va_get_xmm 3 va_sM) ==
make_six_of #quad32
(fun (i: (va_int_range 0 5)) ->
Vale.Def.Types_s.quad32_xor rk
(Vale.X64.Decls.buffer128_read in_b
(count `op_Multiply` 6 + i)
(va_get_mem_heaplet 6 va_sM)))) /\
label va_range1
"***** POSTCONDITION NOT MET AT line 853 column 90 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 8 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite ctr_BE 6)) /\
label va_range1
"***** POSTCONDITION NOT MET AT line 857 column 122 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 2 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b
(in0_count `op_Multiply` 6 + 5)
(va_get_mem_heaplet 6 va_s0))) /\
label va_range1
"***** POSTCONDITION NOT MET AT line 858 column 122 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 3 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b
(in0_count `op_Multiply` 6 + 4)
(va_get_mem_heaplet 6 va_s0))) /\
label va_range1
"***** POSTCONDITION NOT MET AT line 859 column 122 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 4 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b
(in0_count `op_Multiply` 6 + 3)
(va_get_mem_heaplet 6 va_s0))) /\
label va_range1
"***** POSTCONDITION NOT MET AT line 860 column 122 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 5 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b
(in0_count `op_Multiply` 6 + 2)
(va_get_mem_heaplet 6 va_s0))) /\
label va_range1
"***** POSTCONDITION NOT MET AT line 861 column 122 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(Vale.X64.Decls.buffer128_read scratch_b 6 (va_get_mem_heaplet 3 va_sM) ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.X64.Decls.buffer128_read in0_b
(in0_count `op_Multiply` 6 + 1)
(va_get_mem_heaplet 6 va_s0))) /\
label va_range1
"***** POSTCONDITION NOT MET AT line 863 column 90 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(init ==
make_six_of #quad32
(fun (n: (va_int_range 0 5)) ->
Vale.Def.Types_s.quad32_xor (Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GCTR.inc32lite
ctr_BE
n))
(FStar.Seq.Base.index #Vale.Def.Types_s.quad32 round_keys 0))) /\
label va_range1
"***** POSTCONDITION NOT MET AT line 864 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(let eventual_Xi =
add (add (Vale.Math.Poly2.Bits_s.of_quad32 (va_get_xmm 8 va_sM))
(Vale.Math.Poly2.Bits_s.of_quad32 (Vale.X64.Decls.buffer128_read scratch_b
1
(va_get_mem_heaplet 3 va_sM))))
(Vale.Math.Poly2.Bits_s.of_quad32 (va_get_xmm 4 va_sM))
in
label va_range1
"***** POSTCONDITION NOT MET AT line 865 column 94 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/aes/Vale.AES.X64.AESopt.vaf *****"
(eventual_Xi ==
Vale.Math.Poly2.Bits_s.of_quad32 (Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.GHash.ghash_incremental
h_LE
y_prev
data)))))))
in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([
va_Mod_flags; va_Mod_mem_heaplet 3; va_Mod_mem_heaplet 2; va_Mod_xmm 15; va_Mod_xmm 14;
va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 8;
va_Mod_xmm 7; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 4; va_Mod_xmm 3; va_Mod_xmm 2;
va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_reg64 rR11;
va_Mod_reg64 rRbx; va_Mod_ok; va_Mod_mem
])
va_sM
va_s0;
let init = va_g in
(va_sM, va_fM, init) | false |
Spec.SHA3.fst | Spec.SHA3.state_permute | val state_permute (s: state) : Tot state | val state_permute (s: state) : Tot state | let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 29,
"end_line": 90,
"start_col": 0,
"start_line": 89
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false | s: Spec.SHA3.state -> Spec.SHA3.state | Prims.Tot | [
"total"
] | [] | [
"Spec.SHA3.state",
"Lib.LoopCombinators.repeati",
"Spec.SHA3.state_permute1"
] | [] | false | false | false | true | false | let state_permute (s: state) : Tot state =
| repeati 24 state_permute1 s | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.gread | val gread
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h -> B.modifies (loc_slice_from sout pout_from0) h0 h))
(ensures (fun h res h' -> B.modifies B.loc_none h h' /\ res == grvalue r)) | val gread
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h -> B.modifies (loc_slice_from sout pout_from0) h0 h))
(ensures (fun h res h' -> B.modifies B.loc_none h h' /\ res == grvalue r)) | let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f () | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 23,
"end_line": 951,
"start_col": 0,
"start_line": 936
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: LowParse.Low.Writers.greader h0 sout pout_from0 t -> FStar.HyperStack.ST.Stack t | FStar.HyperStack.ST.Stack | [] | [] | [
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.greader",
"FStar.Ghost.erased",
"Prims.unit",
"LowStar.Monotonic.Buffer.modifies",
"LowParse.Slice.loc_slice_from",
"Prims.l_and",
"LowStar.Monotonic.Buffer.loc_none",
"Prims.eq2",
"FStar.Ghost.reveal",
"LowParse.Low.Writers.grvalue"
] | [] | false | true | false | false | false | let gread
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h -> B.modifies (loc_slice_from sout pout_from0) h0 h))
(ensures (fun h res h' -> B.modifies B.loc_none h h' /\ res == grvalue r)) =
| match r with | GReader _ f -> f () | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.graccess | val graccess
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(#g: gaccessor p1 p2 cl)
(a: accessor g)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k1.parser_kind_subkind == Some ParserStrong /\
k2.parser_kind_subkind == Some ParserStrong /\ valid p1 h0 sin pin /\
cl.clens_cond (contents p1 h0 sin pin) /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p1 h0 sin pin))
(loc_slice_from sout pout_from0) })
: Tot (r: greader h0 sout pout_from0 U32.t {grvalue r == slice_access h0 g sin pin}) | val graccess
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(#g: gaccessor p1 p2 cl)
(a: accessor g)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k1.parser_kind_subkind == Some ParserStrong /\
k2.parser_kind_subkind == Some ParserStrong /\ valid p1 h0 sin pin /\
cl.clens_cond (contents p1 h0 sin pin) /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p1 h0 sin pin))
(loc_slice_from sout pout_from0) })
: Tot (r: greader h0 sout pout_from0 U32.t {grvalue r == slice_access h0 g sin pin}) | let graccess
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(#g: gaccessor p1 p2 cl)
(a: accessor g)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k1.parser_kind_subkind == Some ParserStrong /\
k2.parser_kind_subkind == Some ParserStrong /\
valid p1 h0 sin pin /\
cl.clens_cond (contents p1 h0 sin pin) /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p1 h0 sin pin)) (loc_slice_from sout pout_from0)
})
: Tot (r: greader h0 sout pout_from0 U32.t { grvalue r == slice_access h0 g sin pin } )
= GReader (Ghost.hide (slice_access h0 g sin pin)) (fun _ ->
a sin pin
) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 1089,
"start_col": 0,
"start_line": 1064
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f ()
inline_for_extraction
noextract
let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : swriter s h0 space_beyond sout pout_from0 { swvalue w' == swvalue (w (grvalue r)) } )
= SWriter (Ghost.hide (swvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
swrite (w v) pout_from
)
inline_for_extraction
noextract
let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (writer s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : writer s h0 sout pout_from0 { wvalue w' == wvalue (w (grvalue r)) } )
= Writer (Ghost.hide (wvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
write (w v) pout_from
)
inline_for_extraction
noextract
let owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (owriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : owriter s h0 sout pout_from0 { owvalue w' == owvalue (w (grvalue r))})
= OWriter (Ghost.hide (owvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
owrite (w v) pout_from
)
inline_for_extraction
noextract
let lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (lwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : lwriter s h0 sout pout_from0 { lwvalue w' == lwvalue (w (grvalue r)) } )
= LWriter (Ghost.hide (lwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
lwrite (w v) pout_from
)
inline_for_extraction
noextract
let olwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (olwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Pure (olwriter s h0 sout pout_from0)
(requires True)
(ensures (fun w' -> olwvalue w' == olwvalue (w (grvalue r))))
= OLWriter (Ghost.hide (olwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
olwrite (w v) pout_from
)
inline_for_extraction
noextract
let greader_tot
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(#t: Type)
(x: t)
: Tot (r: greader h0 sout pout_from0 t { grvalue r == x } )
= GReader (Ghost.hide x) (fun _ -> x)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: LowParse.Low.Base.accessor g ->
sin: LowParse.Slice.slice rrel rel ->
pin: FStar.UInt32.t ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
pout_from0: FStar.UInt32.t ->
h0:
FStar.Monotonic.HyperStack.mem
{ Mkparser_kind'?.parser_kind_subkind k1 ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
Mkparser_kind'?.parser_kind_subkind k2 ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.valid p1 h0 sin pin /\
Mkclens?.clens_cond cl (LowParse.Low.Base.Spec.contents p1 h0 sin pin) /\
LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from_to sin
pin
(LowParse.Low.Base.Spec.get_valid_pos p1 h0 sin pin))
(LowParse.Slice.loc_slice_from sout pout_from0) }
-> r:
LowParse.Low.Writers.greader h0 sout pout_from0 FStar.UInt32.t
{LowParse.Low.Writers.grvalue r == LowParse.Low.Base.Spec.slice_access h0 g sin pin} | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor",
"LowParse.Low.Base.accessor",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Slice.srel_of_buffer_srel",
"LowStar.Buffer.trivial_preorder",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"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",
"LowParse.Low.Base.Spec.valid",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"LowParse.Low.Base.Spec.contents",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Slice.loc_slice_from",
"LowParse.Low.Writers.GReader",
"FStar.Ghost.hide",
"LowParse.Low.Base.Spec.slice_access",
"Prims.unit",
"LowParse.Low.Writers.greader",
"LowParse.Low.Writers.grvalue"
] | [] | false | false | false | false | false | let graccess
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(#g: gaccessor p1 p2 cl)
(a: accessor g)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k1.parser_kind_subkind == Some ParserStrong /\
k2.parser_kind_subkind == Some ParserStrong /\ valid p1 h0 sin pin /\
cl.clens_cond (contents p1 h0 sin pin) /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p1 h0 sin pin))
(loc_slice_from sout pout_from0) })
: Tot (r: greader h0 sout pout_from0 U32.t {grvalue r == slice_access h0 g sin pin}) =
| GReader (Ghost.hide (slice_access h0 g sin pin)) (fun _ -> a sin pin) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.lwriter_ifthenelse | val lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot
(x:
lwriter s h0 sout pout_from0
{lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ()))}) | val lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot
(x:
lwriter s h0 sout pout_from0
{lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ()))}) | let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 95,
"end_line": 451,
"start_col": 0,
"start_line": 438
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
cond: Prims.bool ->
wtrue: (_: Prims.squash (cond == true) -> LowParse.Low.Writers.lwriter s h0 sout pout_from0) ->
wfalse: (_: Prims.squash (cond == false) -> LowParse.Low.Writers.lwriter s h0 sout pout_from0)
-> x:
LowParse.Low.Writers.lwriter s h0 sout pout_from0
{ LowParse.Low.Writers.lwvalue x ==
(match cond with
| true -> LowParse.Low.Writers.lwvalue (wtrue ())
| _ -> LowParse.Low.Writers.lwvalue (wfalse ())) } | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"Prims.bool",
"Prims.squash",
"LowParse.Low.Writers.lwriter",
"LowParse.Low.Writers.LWriter",
"LowParse.Low.Writers.__proj__LWriter__item__v",
"FStar.Ghost.erased",
"Prims.list",
"LowParse.Low.Writers.lwrite",
"LowParse.Low.Writers.lwvalue"
] | [] | false | false | false | false | false | let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot
(x:
lwriter s h0 sout pout_from0
{lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ()))}) =
| LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from) | false |
Steel.Primitive.ForkJoin.Unix.fst | Steel.Primitive.ForkJoin.Unix.test_lift | val test_lift (#p #q: _) (f: (unit -> SteelK unit p (fun _ -> q))) : SteelK unit p (fun _ -> q) | val test_lift (#p #q: _) (f: (unit -> SteelK unit p (fun _ -> q))) : SteelK unit p (fun _ -> q) | let test_lift #p #q (f : unit -> SteelK unit p (fun _ -> q)) : SteelK unit p (fun _ -> q) =
();
f ();
() | {
"file_name": "lib/steel/Steel.Primitive.ForkJoin.Unix.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 4,
"end_line": 183,
"start_col": 0,
"start_line": 180
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Primitive.ForkJoin.Unix
(* This module shows that it's possible to layer continuations on top
of SteelT to get a direct style (or Unix style) fork/join. Very much a
prototype for now. *)
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open Steel.Reference
open Steel.Primitive.ForkJoin
#set-options "--warn_error -330" //turn off the experimental feature warning
#set-options "--ide_id_info_off"
// (* Some helpers *)
let change_slprop_equiv (p q : vprop)
(proof : squash (p `equiv` q))
: SteelT unit p (fun _ -> q)
= rewrite_slprop p q (fun _ -> proof; reveal_equiv p q)
let change_slprop_imp (p q : vprop)
(proof : squash (p `can_be_split` q))
: SteelT unit p (fun _ -> q)
= rewrite_slprop p q (fun _ -> proof; reveal_can_be_split ())
(* Continuations into unit, but parametrized by the final heap
* proposition and with an implicit framing. I think ideally these would
* also be parametric in the final type (instead of being hardcoded to
* unit) but that means fork needs to be extended to be polymorphic in
* at least one of the branches. *)
type steelK (t:Type u#aa) (framed:bool) (pre : vprop) (post:t->vprop) =
#frame:vprop -> #postf:vprop ->
f:(x:t -> SteelT unit (frame `star` post x) (fun _ -> postf)) ->
SteelT unit (frame `star` pre) (fun _ -> postf)
(* The classic continuation monad *)
let return_ a (x:a) (#[@@@ framing_implicit] p: a -> vprop) : steelK a true (return_pre (p x)) p =
fun k -> k x
private
let rearrange3 (p q r:vprop) : Lemma
(((p `star` q) `star` r) `equiv` (p `star` (r `star` q)))
= let open FStar.Tactics in
assert (((p `star` q) `star` r) `equiv` (p `star` (r `star` q))) by
(norm [delta_attr [`%__reduce__]]; canon' false (`true_p) (`true_p))
private
let equiv_symmetric (p1 p2:vprop)
: Lemma (requires p1 `equiv` p2) (ensures p2 `equiv` p1)
= reveal_equiv p1 p2;
equiv_symmetric (hp_of p1) (hp_of p2);
reveal_equiv p2 p1
private
let can_be_split_forall_frame (#a:Type) (p q:post_t a) (frame:vprop) (x:a)
: Lemma (requires can_be_split_forall p q)
(ensures (frame `star` p x) `can_be_split` (frame `star` q x))
= let frame = hp_of frame in
let p = hp_of (p x) in
let q = hp_of (q x) in
reveal_can_be_split ();
assert (slimp p q);
slimp_star p q frame frame;
Steel.Memory.star_commutative p frame;
Steel.Memory.star_commutative q frame
let bind (a:Type) (b:Type)
(#framed_f:eqtype_as_type bool) (#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] pre_g:a -> pre_t) (#[@@@ framing_implicit] post_g:post_t b)
(#[@@@ framing_implicit] frame_f:vprop) (#[@@@ framing_implicit] frame_g:vprop)
(#[@@@ framing_implicit] p:squash (can_be_split_forall
(fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g)))
(#[@@@ framing_implicit] m1 : squash (maybe_emp framed_f frame_f))
(#[@@@ framing_implicit] m2:squash (maybe_emp framed_g frame_g))
(f:steelK a framed_f pre_f post_f)
(g:(x:a -> steelK b framed_g (pre_g x) post_g))
: steelK b
true
(pre_f `star` frame_f)
(fun y -> post_g y `star` frame_g)
= fun #frame (#post:vprop) (k:(y:b -> SteelT unit (frame `star` (post_g y `star` frame_g)) (fun _ -> post))) ->
// Need SteelT unit (frame `star` (pre_f `star` frame_f)) (fun _ -> post)
change_slprop_equiv (frame `star` (pre_f `star` frame_f)) ((frame `star` frame_f) `star` pre_f) (rearrange3 frame frame_f pre_f;
equiv_symmetric ((frame `star` frame_f) `star` pre_f) (frame `star` (pre_f `star` frame_f)) );
f #(frame `star` frame_f) #post
((fun (x:a) ->
// Need SteelT unit ((frame `star` frame_f) `star` post_f x) (fun _ -> post)
change_slprop_imp
(frame `star` (post_f x `star` frame_f))
(frame `star` (pre_g x `star` frame_g))
(can_be_split_forall_frame (fun x -> post_f x `star` frame_f) (fun x -> pre_g x `star` frame_g) frame x);
g x #(frame `star` frame_g) #post
((fun (y:b) -> k y)
<: (y:b -> SteelT unit ((frame `star` frame_g) `star` post_g y) (fun _ -> post)))
)
<: (x:a -> SteelT unit ((frame `star` frame_f) `star` post_f x) (fun _ -> post)))
let subcomp (a:Type)
(#framed_f:eqtype_as_type bool) (#framed_g:eqtype_as_type bool)
(#[@@@ framing_implicit] pre_f:pre_t) (#[@@@ framing_implicit] post_f:post_t a)
(#[@@@ framing_implicit] pre_g:pre_t) (#[@@@ framing_implicit] post_g:post_t a)
(#[@@@ framing_implicit] p1:squash (can_be_split pre_g pre_f))
(#[@@@ framing_implicit] p2:squash (can_be_split_forall post_f post_g))
(f:steelK a framed_f pre_f post_f)
: Tot (steelK a framed_g pre_g post_g)
= fun #frame #postf (k:(x:a -> SteelT unit (frame `star` post_g x) (fun _ -> postf))) ->
change_slprop_imp pre_g pre_f ();
f #frame #postf ((fun x -> change_slprop_imp (frame `star` post_f x) (frame `star` post_g x)
(can_be_split_forall_frame post_f post_g frame x);
k x) <: (x:a -> SteelT unit (frame `star` post_f x) (fun _ -> postf)))
// let if_then_else (a:Type u#aa)
// (#[@@@ framing_implicit] pre1:pre_t)
// (#[@@@ framing_implicit] post1:post_t a)
// (f : steelK a pre1 post1)
// (g : steelK a pre1 post1)
// (p:Type0) : Type =
// steelK a pre1 post1
// We did not define a bind between Div and Steel, so we indicate
// SteelKF as total to be able to reify and compose it when implementing fork
// This module is intended as proof of concept
total
reifiable
reflectable
layered_effect {
SteelKBase : a:Type -> framed:bool -> pre:vprop -> post:(a->vprop) -> Effect
with
repr = steelK;
return = return_;
bind = bind;
subcomp = subcomp
// if_then_else = if_then_else
}
effect SteelK (a:Type) (pre:pre_t) (post:post_t a) =
SteelKBase a false pre post
effect SteelKF (a:Type) (pre:pre_t) (post:post_t a) =
SteelKBase a true pre post
// We would need requires/ensures in SteelK to have a binding with Pure.
// But for our example, Tot is here sufficient
let bind_tot_steelK_ (a:Type) (b:Type)
(#framed:eqtype_as_type bool)
(#[@@@ framing_implicit] pre:pre_t) (#[@@@ framing_implicit] post:post_t b)
(f:eqtype_as_type unit -> Tot a) (g:(x:a -> steelK b framed pre post))
: steelK b
framed
pre
post
= fun #frame #postf (k:(x:b -> SteelT unit (frame `star` post x) (fun _ -> postf))) ->
let x = f () in
g x #frame #postf k
polymonadic_bind (PURE, SteelKBase) |> SteelKBase = bind_tot_steelK_ | {
"checked_file": "/",
"dependencies": [
"Steel.Reference.fsti.checked",
"Steel.Primitive.ForkJoin.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.Primitive.ForkJoin.Unix.fst"
} | [
{
"abbrev": false,
"full_module": "Steel.Primitive.ForkJoin",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive.ForkJoin",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive.ForkJoin",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | f: (_: Prims.unit -> Steel.Primitive.ForkJoin.Unix.SteelK Prims.unit)
-> Steel.Primitive.ForkJoin.Unix.SteelK Prims.unit | Steel.Primitive.ForkJoin.Unix.SteelK | [] | [] | [
"Steel.Effect.Common.pre_t",
"Steel.Effect.Common.vprop",
"Prims.unit"
] | [] | false | true | false | false | false | let test_lift #p #q (f: (unit -> SteelK unit p (fun _ -> q))) : SteelK unit p (fun _ -> q) =
| ();
f ();
() | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.wbind | val wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (writer s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': writer s h0 sout pout_from0 {wvalue w' == wvalue (w (grvalue r))}) | val wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (writer s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': writer s h0 sout pout_from0 {wvalue w' == wvalue (w (grvalue r))}) | let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (writer s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : writer s h0 sout pout_from0 { wvalue w' == wvalue (w (grvalue r)) } )
= Writer (Ghost.hide (wvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
write (w v) pout_from
) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 990,
"start_col": 0,
"start_line": 975
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f ()
inline_for_extraction
noextract
let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : swriter s h0 space_beyond sout pout_from0 { swvalue w' == swvalue (w (grvalue r)) } )
= SWriter (Ghost.hide (swvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
swrite (w v) pout_from
)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: LowParse.Low.Writers.greader h0 sout pout_from0 tr ->
w: (x: tr -> Prims.Pure (LowParse.Low.Writers.writer s h0 sout pout_from0))
-> w':
LowParse.Low.Writers.writer s h0 sout pout_from0
{ LowParse.Low.Writers.wvalue w' ==
LowParse.Low.Writers.wvalue (w (LowParse.Low.Writers.grvalue r)) } | Prims.Tot | [
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.greader",
"LowParse.Low.Writers.writer",
"LowParse.Low.Writers.grvalue",
"Prims.l_True",
"LowParse.Low.Writers.Writer",
"FStar.Ghost.hide",
"LowParse.Low.Writers.wvalue",
"LowParse.Low.Writers.write",
"LowParse.Low.Writers.gread"
] | [] | false | false | false | false | false | let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (writer s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': writer s h0 sout pout_from0 {wvalue w' == wvalue (w (grvalue r))}) =
| Writer (Ghost.hide (wvalue (w (grvalue r))))
(fun pout_from ->
let v = gread r in
write (w v) pout_from) | false |
Spec.SHA3.fst | Spec.SHA3.state_pi_rho | val state_pi_rho (s_theta: state) : Tot state | val state_pi_rho (s_theta: state) : Tot state | let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 64,
"start_col": 0,
"start_line": 60
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false | s_theta: Spec.SHA3.state -> Spec.SHA3.state | Prims.Tot | [
"total"
] | [] | [
"Spec.SHA3.state",
"Lib.IntTypes.uint64",
"Spec.SHA3.state_pi_rho_s",
"Lib.LoopCombinators.repeat_gen",
"Spec.SHA3.state_pi_rho_inner",
"FStar.Pervasives.Native.Mktuple2",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA3.get"
] | [] | false | false | false | true | false | let state_pi_rho (s_theta: state) : Tot state =
| let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s state_pi_rho_inner (current, s_theta) in
s_pi_rho | false |
Spec.SHA3.fst | Spec.SHA3.absorb | val absorb
(s: state)
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen: nat)
(input: bytes{length input == inputByteLen})
(delimitedSuffix: byte_t)
: Tot state | val absorb
(s: state)
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen: nat)
(input: bytes{length input == inputByteLen})
(delimitedSuffix: byte_t)
: Tot state | let absorb
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(delimitedSuffix:byte_t) :
Tot state =
repeat_blocks rateInBytes input
(absorb_inner rateInBytes)
(absorb_last delimitedSuffix rateInBytes) s | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 45,
"end_line": 157,
"start_col": 0,
"start_line": 147
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s
let storeState_inner (s:state) (j:size_nat{j < 25}) (block:lbytes 200) : Tot (lbytes 200) =
update_sub block (j * 8) 8 (uint_to_bytes_le #U64 s.[j])
let storeState (rateInBytes:size_nat{rateInBytes <= 200}) (s:state) : Tot (lbytes rateInBytes) =
let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes
let absorb_next (s:state) (rateInBytes:size_nat{rateInBytes > 0 /\ rateInBytes <= 200}) : Tot state =
let nextBlock = create rateInBytes (u8 0) in
let nextBlock = nextBlock.[rateInBytes - 1] <- u8 0x80 in
let s = loadState rateInBytes nextBlock s in
state_permute s
val absorb_last:
delimitedSuffix:byte_t
-> rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200}
-> rem:size_nat{rem < rateInBytes}
-> input:lbytes rem
-> s:state ->
Tot state
let absorb_last delimitedSuffix rateInBytes rem input s =
let lastBlock = create rateInBytes (u8 0) in
let lastBlock = update_sub lastBlock 0 rem input in
let lastBlock = lastBlock.[rem] <- byte_to_uint8 delimitedSuffix in
let s = loadState rateInBytes lastBlock s in
let s =
if not ((delimitedSuffix &. byte 0x80) =. byte 0) &&
(rem = rateInBytes - 1)
then state_permute s else s in
absorb_next s rateInBytes
let absorb_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block:lbytes rateInBytes)
(s:state) :
Tot state =
let s = loadState rateInBytes block s in
state_permute s | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false |
s: Spec.SHA3.state ->
rateInBytes: Lib.IntTypes.size_nat{0 < rateInBytes /\ rateInBytes <= 200} ->
inputByteLen: Prims.nat ->
input: Lib.ByteSequence.bytes{Lib.Sequence.length input == inputByteLen} ->
delimitedSuffix: Lib.IntTypes.byte_t
-> Spec.SHA3.state | Prims.Tot | [
"total"
] | [] | [
"Spec.SHA3.state",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"Prims.nat",
"Lib.ByteSequence.bytes",
"Prims.eq2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.IntTypes.byte_t",
"Lib.Sequence.repeat_blocks",
"Spec.SHA3.absorb_inner",
"Spec.SHA3.absorb_last"
] | [] | false | false | false | false | false | let absorb
(s: state)
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen: nat)
(input: bytes{length input == inputByteLen})
(delimitedSuffix: byte_t)
: Tot state =
| repeat_blocks rateInBytes
input
(absorb_inner rateInBytes)
(absorb_last delimitedSuffix rateInBytes)
s | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.grlexistsb | val grlexistsb
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> Tot bool))
(f':
(#rrel: _ -> #rel: _ -> sl: slice rrel rel -> pos: U32.t
-> HST.Stack bool
(requires (fun h -> valid p h sl pos))
(ensures
(fun h res h' -> B.modifies B.loc_none h h' /\ res == f (contents p h sl pos))))
)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos': U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k.parser_kind_subkind == Some ParserStrong /\ valid_list p h0 sl pos pos' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') (loc_slice_from sout pout_from0) })
: Tot
(r':
greader h0 sout pout_from0 bool {grvalue r' == L.existsb f (contents_list p h0 sl pos pos')}) | val grlexistsb
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> Tot bool))
(f':
(#rrel: _ -> #rel: _ -> sl: slice rrel rel -> pos: U32.t
-> HST.Stack bool
(requires (fun h -> valid p h sl pos))
(ensures
(fun h res h' -> B.modifies B.loc_none h h' /\ res == f (contents p h sl pos))))
)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos': U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k.parser_kind_subkind == Some ParserStrong /\ valid_list p h0 sl pos pos' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') (loc_slice_from sout pout_from0) })
: Tot
(r':
greader h0 sout pout_from0 bool {grvalue r' == L.existsb f (contents_list p h0 sl pos pos')}) | let grlexistsb
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> Tot bool)) // should be GTot, but List.find requires Tot
(f' : (
(#rrel: _) ->
(#rel: _) ->
(sl: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack bool
(requires (fun h ->
valid p h sl pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (contents p h sl pos)
))
))
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos' : U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k.parser_kind_subkind == Some ParserStrong /\
valid_list p h0 sl pos pos' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') (loc_slice_from sout pout_from0)
})
: Tot (r' : greader h0 sout pout_from0 bool { grvalue r' == L.existsb f (contents_list p h0 sl pos pos') } )
= GReader (Ghost.hide (L.existsb f (contents_list p h0 sl pos pos'))) (fun _ ->
list_existsb j f f' sl pos pos'
) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 1148,
"start_col": 0,
"start_line": 1115
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f ()
inline_for_extraction
noextract
let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : swriter s h0 space_beyond sout pout_from0 { swvalue w' == swvalue (w (grvalue r)) } )
= SWriter (Ghost.hide (swvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
swrite (w v) pout_from
)
inline_for_extraction
noextract
let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (writer s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : writer s h0 sout pout_from0 { wvalue w' == wvalue (w (grvalue r)) } )
= Writer (Ghost.hide (wvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
write (w v) pout_from
)
inline_for_extraction
noextract
let owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (owriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : owriter s h0 sout pout_from0 { owvalue w' == owvalue (w (grvalue r))})
= OWriter (Ghost.hide (owvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
owrite (w v) pout_from
)
inline_for_extraction
noextract
let lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (lwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : lwriter s h0 sout pout_from0 { lwvalue w' == lwvalue (w (grvalue r)) } )
= LWriter (Ghost.hide (lwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
lwrite (w v) pout_from
)
inline_for_extraction
noextract
let olwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (olwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Pure (olwriter s h0 sout pout_from0)
(requires True)
(ensures (fun w' -> olwvalue w' == olwvalue (w (grvalue r))))
= OLWriter (Ghost.hide (olwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
olwrite (w v) pout_from
)
inline_for_extraction
noextract
let greader_tot
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(#t: Type)
(x: t)
: Tot (r: greader h0 sout pout_from0 t { grvalue r == x } )
= GReader (Ghost.hide x) (fun _ -> x)
inline_for_extraction
noextract
let graccess
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(#g: gaccessor p1 p2 cl)
(a: accessor g)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k1.parser_kind_subkind == Some ParserStrong /\
k2.parser_kind_subkind == Some ParserStrong /\
valid p1 h0 sin pin /\
cl.clens_cond (contents p1 h0 sin pin) /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p1 h0 sin pin)) (loc_slice_from sout pout_from0)
})
: Tot (r: greader h0 sout pout_from0 U32.t { grvalue r == slice_access h0 g sin pin } )
= GReader (Ghost.hide (slice_access h0 g sin pin)) (fun _ ->
a sin pin
)
inline_for_extraction
noextract
let read_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(r: leaf_reader p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k.parser_kind_subkind == Some ParserStrong /\
valid p h0 sin pin /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p h0 sin pin)) (loc_slice_from sout pout_from0)
})
: Tot (r' : greader h0 sout pout_from0 t { grvalue r' == contents p h0 sin pin } )
= GReader (Ghost.hide (contents p h0 sin pin)) (fun _ ->
r sin pin
)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
j: LowParse.Low.Base.jumper p ->
f: (_: t -> Prims.bool) ->
f':
(sl: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t
-> FStar.HyperStack.ST.Stack Prims.bool) ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
pout_from0: FStar.UInt32.t ->
h0:
FStar.Monotonic.HyperStack.mem
{ Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.valid_list p h0 sl pos pos' /\
LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from_to sl pos pos')
(LowParse.Slice.loc_slice_from sout pout_from0) }
-> r':
LowParse.Low.Writers.greader h0 sout pout_from0 Prims.bool
{ LowParse.Low.Writers.grvalue r' ==
FStar.List.Tot.Base.existsb f (LowParse.Low.Base.Spec.contents_list p h0 sl pos pos') } | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.jumper",
"Prims.bool",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Low.Base.Spec.valid",
"Prims.l_and",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_none",
"Prims.eq2",
"LowParse.Low.Base.Spec.contents",
"LowParse.Slice.srel_of_buffer_srel",
"LowStar.Buffer.trivial_preorder",
"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",
"LowParse.Low.Base.Spec.valid_list",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"LowParse.Slice.loc_slice_from",
"LowParse.Low.Writers.GReader",
"FStar.Ghost.hide",
"FStar.List.Tot.Base.existsb",
"LowParse.Low.Base.Spec.contents_list",
"Prims.unit",
"LowParse.Low.Base.list_existsb",
"LowParse.Low.Writers.greader",
"LowParse.Low.Writers.grvalue"
] | [] | false | false | false | false | false | let grlexistsb
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> Tot bool))
(f':
(#rrel: _ -> #rel: _ -> sl: slice rrel rel -> pos: U32.t
-> HST.Stack bool
(requires (fun h -> valid p h sl pos))
(ensures
(fun h res h' -> B.modifies B.loc_none h h' /\ res == f (contents p h sl pos))))
)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos': U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k.parser_kind_subkind == Some ParserStrong /\ valid_list p h0 sl pos pos' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') (loc_slice_from sout pout_from0) })
: Tot
(r':
greader h0 sout pout_from0 bool {grvalue r' == L.existsb f (contents_list p h0 sl pos pos')}) =
| GReader (Ghost.hide (L.existsb f (contents_list p h0 sl pos pos')))
(fun _ -> list_existsb j f f' sl pos pos') | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.lwriter_list_map | val lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 {k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0})
(f: (t1 -> Tot t2))
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0:
U32.t
{ B.loc_disjoint (loc_slice_from sout pout_from0)
(loc_slice_from_to sin pin_from pin_to) /\ valid_list p1 h0 sin pin_from pin_to })
(f':
(
pos:
U32.t
{ U32.v pin_from <= U32.v pos /\ valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to }
-> Tot (y: writer s2 h0 sout pout_from0 {wvalue y == f (contents p1 h0 sin pos)})))
: Tot
(x:
lwriter s2 h0 sout pout_from0
{lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to)}) | val lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 {k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0})
(f: (t1 -> Tot t2))
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0:
U32.t
{ B.loc_disjoint (loc_slice_from sout pout_from0)
(loc_slice_from_to sin pin_from pin_to) /\ valid_list p1 h0 sin pin_from pin_to })
(f':
(
pos:
U32.t
{ U32.v pin_from <= U32.v pos /\ valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to }
-> Tot (y: writer s2 h0 sout pout_from0 {wvalue y == f (contents p1 h0 sin pos)})))
: Tot
(x:
lwriter s2 h0 sout pout_from0
{lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to)}) | let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 497,
"start_col": 0,
"start_line": 455
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
j1: LowParse.Low.Base.jumper p1 ->
s2:
LowParse.Spec.Base.serializer p2
{ Mkparser_kind'?.parser_kind_subkind k2 ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
Mkparser_kind'?.parser_kind_low k2 > 0 } ->
f: (_: t1 -> t2) ->
sin: LowParse.Slice.slice rrel rel ->
pin_from: FStar.UInt32.t ->
pin_to: FStar.UInt32.t ->
h0: FStar.Monotonic.HyperStack.mem ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
pout_from0:
FStar.UInt32.t
{ LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from sout pout_from0)
(LowParse.Slice.loc_slice_from_to sin pin_from pin_to) /\
LowParse.Low.Base.Spec.valid_list p1 h0 sin pin_from pin_to } ->
f':
(
pos:
FStar.UInt32.t
{ FStar.UInt32.v pin_from <= FStar.UInt32.v pos /\
LowParse.Low.Base.Spec.valid p1 h0 sin pos /\
FStar.UInt32.v pos + LowParse.Low.Base.Spec.content_length p1 h0 sin pos <=
FStar.UInt32.v pin_to }
-> y:
LowParse.Low.Writers.writer s2 h0 sout pout_from0
{LowParse.Low.Writers.wvalue y == f (LowParse.Low.Base.Spec.contents p1 h0 sin pos)})
-> x:
LowParse.Low.Writers.lwriter s2 h0 sout pout_from0
{ LowParse.Low.Writers.lwvalue x ==
FStar.List.Tot.Base.map f (LowParse.Low.Base.Spec.contents_list p1 h0 sin pin_from pin_to) } | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.jumper",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.srel_of_buffer_srel",
"LowStar.Buffer.trivial_preorder",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from",
"LowParse.Slice.loc_slice_from_to",
"LowParse.Low.Base.Spec.valid_list",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowParse.Low.Base.Spec.valid",
"Prims.op_Addition",
"LowParse.Low.Base.Spec.content_length",
"LowParse.Low.Writers.writer",
"LowParse.Low.Writers.wvalue",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Writers.LWriter",
"FStar.Ghost.hide",
"Prims.list",
"FStar.List.Tot.Base.map",
"LowParse.Low.Base.Spec.contents_list",
"LowParse.Low.Base.list_map",
"LowParse.Low.Writers.write",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_pos_frame_strong",
"LowParse.Low.Base.Spec.get_valid_pos",
"FStar.HyperStack.ST.get",
"Prims._assert",
"LowParse.Low.Writers.lwriter",
"LowParse.Low.Writers.lwvalue"
] | [] | false | false | false | false | false | let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 {k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0})
(f: (t1 -> Tot t2))
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0:
U32.t
{ B.loc_disjoint (loc_slice_from sout pout_from0)
(loc_slice_from_to sin pin_from pin_to) /\ valid_list p1 h0 sin pin_from pin_to })
(f':
(
pos:
U32.t
{ U32.v pin_from <= U32.v pos /\ valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to }
-> Tot (y: writer s2 h0 sout pout_from0 {wvalue y == f (contents p1 h0 sin pos)})))
: Tot
(x:
lwriter s2 h0 sout pout_from0
{lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to)}) =
| LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to)))
(fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map j1 s2 f h sin pin_from pin_to sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1
h0
sin
pin_
(get_valid_pos p1 h sin pin_)
(loc_slice_from sout pout_from0)
h;
write (f' pin_) pout_)) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.olwriter_append | val olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot
(x:
olwriter s h0 sout pout_from0
{ olwvalue x ==
(match olwvalue w1, olwvalue w2 with
| Some l1, Some l2 -> Some (l1 `List.Tot.append` l2)
| _ -> None) }) | val olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot
(x:
olwriter s h0 sout pout_from0
{ olwvalue x ==
(match olwvalue w1, olwvalue w2 with
| Some l1, Some l2 -> Some (l1 `List.Tot.append` l2)
| _ -> None) }) | let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 821,
"start_col": 0,
"start_line": 793
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
w1: LowParse.Low.Writers.olwriter s h0 sout pout_from0 ->
w2: LowParse.Low.Writers.olwriter s h0 sout pout_from0
-> x:
LowParse.Low.Writers.olwriter s h0 sout pout_from0
{ LowParse.Low.Writers.olwvalue x ==
(match LowParse.Low.Writers.olwvalue w1, LowParse.Low.Writers.olwvalue w2 with
| FStar.Pervasives.Native.Mktuple2
#_
#_
(FStar.Pervasives.Native.Some #_ l1)
(FStar.Pervasives.Native.Some #_ l2) ->
FStar.Pervasives.Native.Some (l1 @ l2)
| _ -> FStar.Pervasives.Native.None) } | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.olwriter",
"LowParse.Low.Writers.OLWriter",
"FStar.Ghost.hide",
"Prims.list",
"FStar.Pervasives.Native.Mktuple2",
"LowParse.Low.Writers.olwvalue",
"FStar.List.Tot.Base.append",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.None",
"FStar.UInt32.lte",
"FStar.UInt32.sub",
"LowParse.Low.ErrorCode.max_uint32",
"FStar.UInt32.__uint_to_t",
"Prims.bool",
"Prims.unit",
"FStar.UInt32.lt",
"LowParse.Low.Base.Spec.valid_list_serialized_list_length",
"LowParse.Low.Base.Spec.valid_list_append",
"FStar.HyperStack.ST.get",
"LowParse.Low.Writers.olwrite",
"FStar.Classical.forall_intro_2",
"Prims.int",
"LowParse.Low.Base.Spec.serialized_list_length",
"Prims.op_Addition",
"LowParse.Low.Base.Spec.serialized_list_length_append"
] | [] | false | false | false | false | false | let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot
(x:
olwriter s h0 sout pout_from0
{ olwvalue x ==
(match olwvalue w1, olwvalue w2 with
| Some l1, Some l2 -> Some (l1 `List.Tot.append` l2)
| _ -> None) }) =
| OLWriter
(Ghost.hide (match olwvalue w1, olwvalue w2 with
| Some l1, Some l2 -> Some (l1 `List.Tot.append` l2)
| _ -> None))
(fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then res1
else
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then
(valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2);
res2) | false |
Spec.SHA3.fst | Spec.SHA3.state_theta1 | val state_theta1 (s: state) (_C: lseq uint64 5) : Tot state | val state_theta1 (s: state) (_C: lseq uint64 5) : Tot state | let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 42,
"start_col": 0,
"start_line": 41
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false | s: Spec.SHA3.state -> _C: Lib.Sequence.lseq Lib.IntTypes.uint64 5 -> Spec.SHA3.state | Prims.Tot | [
"total"
] | [] | [
"Spec.SHA3.state",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Lib.LoopCombinators.repeati",
"Spec.SHA3.state_theta_inner_s"
] | [] | false | false | false | false | false | let state_theta1 (s: state) (_C: lseq uint64 5) : Tot state =
| repeati 5 (state_theta_inner_s _C) s | false |
Spec.SHA3.fst | Spec.SHA3.storeState | val storeState (rateInBytes: size_nat{rateInBytes <= 200}) (s: state) : Tot (lbytes rateInBytes) | val storeState (rateInBytes: size_nat{rateInBytes <= 200}) (s: state) : Tot (lbytes rateInBytes) | let storeState (rateInBytes:size_nat{rateInBytes <= 200}) (s:state) : Tot (lbytes rateInBytes) =
let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 111,
"start_col": 0,
"start_line": 108
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s
let storeState_inner (s:state) (j:size_nat{j < 25}) (block:lbytes 200) : Tot (lbytes 200) =
update_sub block (j * 8) 8 (uint_to_bytes_le #U64 s.[j]) | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false | rateInBytes: Lib.IntTypes.size_nat{rateInBytes <= 200} -> s: Spec.SHA3.state
-> Lib.ByteSequence.lbytes rateInBytes | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Spec.SHA3.state",
"Lib.Sequence.sub",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.LoopCombinators.repeati",
"Spec.SHA3.storeState_inner",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.op_LessThan",
"Lib.Sequence.index",
"Lib.Sequence.create",
"Lib.IntTypes.u8",
"Lib.ByteSequence.lbytes"
] | [] | false | false | false | false | false | let storeState (rateInBytes: size_nat{rateInBytes <= 200}) (s: state) : Tot (lbytes rateInBytes) =
| let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.olwbind | val olwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (olwriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Pure (olwriter s h0 sout pout_from0)
(requires True)
(ensures (fun w' -> olwvalue w' == olwvalue (w (grvalue r)))) | val olwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (olwriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Pure (olwriter s h0 sout pout_from0)
(requires True)
(ensures (fun w' -> olwvalue w' == olwvalue (w (grvalue r)))) | let olwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (olwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Pure (olwriter s h0 sout pout_from0)
(requires True)
(ensures (fun w' -> olwvalue w' == olwvalue (w (grvalue r))))
= OLWriter (Ghost.hide (olwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
olwrite (w v) pout_from
) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 1049,
"start_col": 0,
"start_line": 1032
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f ()
inline_for_extraction
noextract
let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : swriter s h0 space_beyond sout pout_from0 { swvalue w' == swvalue (w (grvalue r)) } )
= SWriter (Ghost.hide (swvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
swrite (w v) pout_from
)
inline_for_extraction
noextract
let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (writer s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : writer s h0 sout pout_from0 { wvalue w' == wvalue (w (grvalue r)) } )
= Writer (Ghost.hide (wvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
write (w v) pout_from
)
inline_for_extraction
noextract
let owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (owriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : owriter s h0 sout pout_from0 { owvalue w' == owvalue (w (grvalue r))})
= OWriter (Ghost.hide (owvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
owrite (w v) pout_from
)
inline_for_extraction
noextract
let lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (lwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : lwriter s h0 sout pout_from0 { lwvalue w' == lwvalue (w (grvalue r)) } )
= LWriter (Ghost.hide (lwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
lwrite (w v) pout_from
)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: LowParse.Low.Writers.greader h0 sout pout_from0 tr ->
w: (x: tr -> Prims.Pure (LowParse.Low.Writers.olwriter s h0 sout pout_from0))
-> Prims.Pure (LowParse.Low.Writers.olwriter s h0 sout pout_from0) | Prims.Pure | [] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.greader",
"LowParse.Low.Writers.olwriter",
"LowParse.Low.Writers.grvalue",
"Prims.l_True",
"LowParse.Low.Writers.OLWriter",
"FStar.Ghost.hide",
"Prims.list",
"LowParse.Low.Writers.olwvalue",
"LowParse.Low.Writers.olwrite",
"LowParse.Low.Writers.gread"
] | [] | false | false | false | false | false | let olwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (olwriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Pure (olwriter s h0 sout pout_from0)
(requires True)
(ensures (fun w' -> olwvalue w' == olwvalue (w (grvalue r)))) =
| OLWriter (Ghost.hide (olwvalue (w (grvalue r))))
(fun pout_from ->
let v = gread r in
olwrite (w v) pout_from) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.lwbind | val lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (lwriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': lwriter s h0 sout pout_from0 {lwvalue w' == lwvalue (w (grvalue r))}) | val lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (lwriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': lwriter s h0 sout pout_from0 {lwvalue w' == lwvalue (w (grvalue r))}) | let lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (lwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : lwriter s h0 sout pout_from0 { lwvalue w' == lwvalue (w (grvalue r)) } )
= LWriter (Ghost.hide (lwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
lwrite (w v) pout_from
) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 1028,
"start_col": 0,
"start_line": 1013
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f ()
inline_for_extraction
noextract
let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : swriter s h0 space_beyond sout pout_from0 { swvalue w' == swvalue (w (grvalue r)) } )
= SWriter (Ghost.hide (swvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
swrite (w v) pout_from
)
inline_for_extraction
noextract
let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (writer s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : writer s h0 sout pout_from0 { wvalue w' == wvalue (w (grvalue r)) } )
= Writer (Ghost.hide (wvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
write (w v) pout_from
)
inline_for_extraction
noextract
let owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (owriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : owriter s h0 sout pout_from0 { owvalue w' == owvalue (w (grvalue r))})
= OWriter (Ghost.hide (owvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
owrite (w v) pout_from
)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: LowParse.Low.Writers.greader h0 sout pout_from0 tr ->
w: (x: tr -> Prims.Pure (LowParse.Low.Writers.lwriter s h0 sout pout_from0))
-> w':
LowParse.Low.Writers.lwriter s h0 sout pout_from0
{ LowParse.Low.Writers.lwvalue w' ==
LowParse.Low.Writers.lwvalue (w (LowParse.Low.Writers.grvalue r)) } | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.greader",
"LowParse.Low.Writers.lwriter",
"LowParse.Low.Writers.grvalue",
"Prims.l_True",
"LowParse.Low.Writers.LWriter",
"FStar.Ghost.hide",
"Prims.list",
"LowParse.Low.Writers.lwvalue",
"LowParse.Low.Writers.lwrite",
"LowParse.Low.Writers.gread"
] | [] | false | false | false | false | false | let lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (lwriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': lwriter s h0 sout pout_from0 {lwvalue w' == lwvalue (w (grvalue r))}) =
| LWriter (Ghost.hide (lwvalue (w (grvalue r))))
(fun pout_from ->
let v = gread r in
lwrite (w v) pout_from) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.grifthenelse | val grifthenelse
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(cond: bool)
(grtrue: (squash (cond == true) -> Tot (greader h0 sout pout_from0 t)))
(grfalse: (squash (cond == false) -> Tot (greader h0 sout pout_from0 t)))
: Tot
(r':
greader h0 sout pout_from0 t
{grvalue r' == (if cond then grvalue (grtrue ()) else grvalue (grfalse ()))}) | val grifthenelse
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(cond: bool)
(grtrue: (squash (cond == true) -> Tot (greader h0 sout pout_from0 t)))
(grfalse: (squash (cond == false) -> Tot (greader h0 sout pout_from0 t)))
: Tot
(r':
greader h0 sout pout_from0 t
{grvalue r' == (if cond then grvalue (grtrue ()) else grvalue (grfalse ()))}) | let grifthenelse
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(cond: bool)
(grtrue: (squash (cond == true) -> Tot (greader h0 sout pout_from0 t)))
(grfalse: (squash (cond == false) -> Tot (greader h0 sout pout_from0 t)))
: Tot (r' : greader h0 sout pout_from0 t { grvalue r' == (if cond then grvalue (grtrue ()) else grvalue (grfalse ())) } )
= GReader (Ghost.hide (if cond then grvalue (grtrue ()) else grvalue (grfalse ()))) (fun _ ->
if cond then gread (grtrue ()) else gread (grfalse ())
) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 1163,
"start_col": 0,
"start_line": 1152
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f ()
inline_for_extraction
noextract
let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : swriter s h0 space_beyond sout pout_from0 { swvalue w' == swvalue (w (grvalue r)) } )
= SWriter (Ghost.hide (swvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
swrite (w v) pout_from
)
inline_for_extraction
noextract
let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (writer s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : writer s h0 sout pout_from0 { wvalue w' == wvalue (w (grvalue r)) } )
= Writer (Ghost.hide (wvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
write (w v) pout_from
)
inline_for_extraction
noextract
let owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (owriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : owriter s h0 sout pout_from0 { owvalue w' == owvalue (w (grvalue r))})
= OWriter (Ghost.hide (owvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
owrite (w v) pout_from
)
inline_for_extraction
noextract
let lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (lwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : lwriter s h0 sout pout_from0 { lwvalue w' == lwvalue (w (grvalue r)) } )
= LWriter (Ghost.hide (lwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
lwrite (w v) pout_from
)
inline_for_extraction
noextract
let olwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (olwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Pure (olwriter s h0 sout pout_from0)
(requires True)
(ensures (fun w' -> olwvalue w' == olwvalue (w (grvalue r))))
= OLWriter (Ghost.hide (olwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
olwrite (w v) pout_from
)
inline_for_extraction
noextract
let greader_tot
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(#t: Type)
(x: t)
: Tot (r: greader h0 sout pout_from0 t { grvalue r == x } )
= GReader (Ghost.hide x) (fun _ -> x)
inline_for_extraction
noextract
let graccess
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(#g: gaccessor p1 p2 cl)
(a: accessor g)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k1.parser_kind_subkind == Some ParserStrong /\
k2.parser_kind_subkind == Some ParserStrong /\
valid p1 h0 sin pin /\
cl.clens_cond (contents p1 h0 sin pin) /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p1 h0 sin pin)) (loc_slice_from sout pout_from0)
})
: Tot (r: greader h0 sout pout_from0 U32.t { grvalue r == slice_access h0 g sin pin } )
= GReader (Ghost.hide (slice_access h0 g sin pin)) (fun _ ->
a sin pin
)
inline_for_extraction
noextract
let read_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(r: leaf_reader p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k.parser_kind_subkind == Some ParserStrong /\
valid p h0 sin pin /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p h0 sin pin)) (loc_slice_from sout pout_from0)
})
: Tot (r' : greader h0 sout pout_from0 t { grvalue r' == contents p h0 sin pin } )
= GReader (Ghost.hide (contents p h0 sin pin)) (fun _ ->
r sin pin
)
inline_for_extraction
noextract
let grlexistsb
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> Tot bool)) // should be GTot, but List.find requires Tot
(f' : (
(#rrel: _) ->
(#rel: _) ->
(sl: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack bool
(requires (fun h ->
valid p h sl pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (contents p h sl pos)
))
))
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos' : U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k.parser_kind_subkind == Some ParserStrong /\
valid_list p h0 sl pos pos' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') (loc_slice_from sout pout_from0)
})
: Tot (r' : greader h0 sout pout_from0 bool { grvalue r' == L.existsb f (contents_list p h0 sl pos pos') } )
= GReader (Ghost.hide (L.existsb f (contents_list p h0 sl pos pos'))) (fun _ ->
list_existsb j f f' sl pos pos'
)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
cond: Prims.bool ->
grtrue: (_: Prims.squash (cond == true) -> LowParse.Low.Writers.greader h0 sout pout_from0 t) ->
grfalse: (_: Prims.squash (cond == false) -> LowParse.Low.Writers.greader h0 sout pout_from0 t)
-> r':
LowParse.Low.Writers.greader h0 sout pout_from0 t
{ LowParse.Low.Writers.grvalue r' ==
(match cond with
| true -> LowParse.Low.Writers.grvalue (grtrue ())
| _ -> LowParse.Low.Writers.grvalue (grfalse ())) } | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"Prims.bool",
"Prims.squash",
"Prims.eq2",
"LowParse.Low.Writers.greader",
"LowParse.Low.Writers.GReader",
"FStar.Ghost.hide",
"LowParse.Low.Writers.grvalue",
"Prims.unit",
"LowParse.Low.Writers.gread"
] | [] | false | false | false | false | false | let grifthenelse
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(cond: bool)
(grtrue: (squash (cond == true) -> Tot (greader h0 sout pout_from0 t)))
(grfalse: (squash (cond == false) -> Tot (greader h0 sout pout_from0 t)))
: Tot
(r':
greader h0 sout pout_from0 t
{grvalue r' == (if cond then grvalue (grtrue ()) else grvalue (grfalse ()))}) =
| GReader (Ghost.hide (if cond then grvalue (grtrue ()) else grvalue (grfalse ())))
(fun _ -> if cond then gread (grtrue ()) else gread (grfalse ())) | false |
Spec.SHA3.fst | Spec.SHA3.squeeze_inner | val squeeze_inner
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen: size_nat)
(i: size_nat{i < outputByteLen / rateInBytes})
(s: state)
: Tot (state & lbytes rateInBytes) | val squeeze_inner
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen: size_nat)
(i: size_nat{i < outputByteLen / rateInBytes})
(s: state)
: Tot (state & lbytes rateInBytes) | let squeeze_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat)
(i:size_nat{i < outputByteLen / rateInBytes})
(s:state) :
Tot (state & lbytes rateInBytes) =
let block = storeState rateInBytes s in
let s = state_permute s in
s, block | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 168,
"start_col": 0,
"start_line": 159
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s
let storeState_inner (s:state) (j:size_nat{j < 25}) (block:lbytes 200) : Tot (lbytes 200) =
update_sub block (j * 8) 8 (uint_to_bytes_le #U64 s.[j])
let storeState (rateInBytes:size_nat{rateInBytes <= 200}) (s:state) : Tot (lbytes rateInBytes) =
let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes
let absorb_next (s:state) (rateInBytes:size_nat{rateInBytes > 0 /\ rateInBytes <= 200}) : Tot state =
let nextBlock = create rateInBytes (u8 0) in
let nextBlock = nextBlock.[rateInBytes - 1] <- u8 0x80 in
let s = loadState rateInBytes nextBlock s in
state_permute s
val absorb_last:
delimitedSuffix:byte_t
-> rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200}
-> rem:size_nat{rem < rateInBytes}
-> input:lbytes rem
-> s:state ->
Tot state
let absorb_last delimitedSuffix rateInBytes rem input s =
let lastBlock = create rateInBytes (u8 0) in
let lastBlock = update_sub lastBlock 0 rem input in
let lastBlock = lastBlock.[rem] <- byte_to_uint8 delimitedSuffix in
let s = loadState rateInBytes lastBlock s in
let s =
if not ((delimitedSuffix &. byte 0x80) =. byte 0) &&
(rem = rateInBytes - 1)
then state_permute s else s in
absorb_next s rateInBytes
let absorb_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block:lbytes rateInBytes)
(s:state) :
Tot state =
let s = loadState rateInBytes block s in
state_permute s
let absorb
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(delimitedSuffix:byte_t) :
Tot state =
repeat_blocks rateInBytes input
(absorb_inner rateInBytes)
(absorb_last delimitedSuffix rateInBytes) s | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false |
rateInBytes: Lib.IntTypes.size_nat{0 < rateInBytes /\ rateInBytes <= 200} ->
outputByteLen: Lib.IntTypes.size_nat ->
i: Lib.IntTypes.size_nat{i < outputByteLen / rateInBytes} ->
s: Spec.SHA3.state
-> Spec.SHA3.state * Lib.ByteSequence.lbytes rateInBytes | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"Spec.SHA3.state",
"FStar.Pervasives.Native.Mktuple2",
"Lib.ByteSequence.lbytes",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA3.state_permute",
"Lib.IntTypes.U8",
"Spec.SHA3.storeState",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | false | false | let squeeze_inner
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen: size_nat)
(i: size_nat{i < outputByteLen / rateInBytes})
(s: state)
: Tot (state & lbytes rateInBytes) =
| let block = storeState rateInBytes s in
let s = state_permute s in
s, block | false |
Spec.SHA3.fst | Spec.SHA3.state_pi_rho_inner | val state_pi_rho_inner : i: Lib.IntTypes.size_nat{i < 24} ->
_: (Lib.IntTypes.uint64 * Lib.Sequence.lseq Lib.IntTypes.uint64 25)
-> Lib.IntTypes.uint64 * Spec.SHA3.state | let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 12,
"end_line": 55,
"start_col": 0,
"start_line": 49
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false |
i: Lib.IntTypes.size_nat{i < 24} ->
_: (Lib.IntTypes.uint64 * Lib.Sequence.lseq Lib.IntTypes.uint64 25)
-> Lib.IntTypes.uint64 * Spec.SHA3.state | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Pervasives.Native.tuple2",
"Lib.IntTypes.uint64",
"Lib.Sequence.lseq",
"FStar.Pervasives.Native.Mktuple2",
"Spec.SHA3.state",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.eq2",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Prims.l_and",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.upd",
"Spec.SHA3.rotl",
"Lib.Sequence.index",
"Prims.l_Forall",
"Prims.nat",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.l_imp",
"Prims.op_disEquality",
"Prims.l_or",
"Lib.Sequence.op_String_Assignment",
"Lib.Sequence.op_String_Access",
"Prims.int",
"Lib.IntTypes.range",
"Lib.IntTypes.U32",
"Lib.IntTypes.v",
"Lib.IntTypes.PUB",
"Spec.SHA3.Constants.piln_t",
"Spec.SHA3.Constants.keccak_piln",
"Spec.SHA3.Constants.rotc_t",
"Spec.SHA3.Constants.keccak_rotc"
] | [] | false | false | false | false | false | let state_pi_rho_inner (i: size_nat{i < 24}) (current, s) : (uint64 & state) =
| let r = keccak_rotc.[ i ] in
let _Y = v keccak_piln.[ i ] in
let temp = s.[ _Y ] in
let s = s.[ _Y ] <- rotl current r in
let current = temp in
current, s | false |
|
Spec.SHA3.fst | Spec.SHA3.state_theta_inner_s | val state_theta_inner_s (_C: lseq uint64 5) (x: index) (s: state) : Tot state | val state_theta_inner_s (_C: lseq uint64 5) (x: index) (s: state) : Tot state | let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 46,
"end_line": 39,
"start_col": 0,
"start_line": 37
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D) | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false | _C: Lib.Sequence.lseq Lib.IntTypes.uint64 5 -> x: Spec.SHA3.index -> s: Spec.SHA3.state
-> Spec.SHA3.state | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Spec.SHA3.index",
"Spec.SHA3.state",
"Lib.LoopCombinators.repeati",
"Spec.SHA3.state_theta_inner_s_inner",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.IntTypes.op_Hat_Dot",
"Lib.Sequence.op_String_Access",
"Prims.op_Modulus",
"Prims.op_Addition",
"Spec.SHA3.rotl",
"Lib.IntTypes.size"
] | [] | false | false | false | false | false | let state_theta_inner_s (_C: lseq uint64 5) (x: index) (s: state) : Tot state =
| let _D = _C.[ (x + 4) % 5 ] ^. (rotl _C.[ (x + 1) % 5 ] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.read_leaf | val read_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(r: leaf_reader p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k.parser_kind_subkind == Some ParserStrong /\ valid p h0 sin pin /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p h0 sin pin))
(loc_slice_from sout pout_from0) })
: Tot (r': greader h0 sout pout_from0 t {grvalue r' == contents p h0 sin pin}) | val read_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(r: leaf_reader p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k.parser_kind_subkind == Some ParserStrong /\ valid p h0 sin pin /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p h0 sin pin))
(loc_slice_from sout pout_from0) })
: Tot (r': greader h0 sout pout_from0 t {grvalue r' == contents p h0 sin pin}) | let read_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(r: leaf_reader p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k.parser_kind_subkind == Some ParserStrong /\
valid p h0 sin pin /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p h0 sin pin)) (loc_slice_from sout pout_from0)
})
: Tot (r' : greader h0 sout pout_from0 t { grvalue r' == contents p h0 sin pin } )
= GReader (Ghost.hide (contents p h0 sin pin)) (fun _ ->
r sin pin
) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 1111,
"start_col": 0,
"start_line": 1093
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f ()
inline_for_extraction
noextract
let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : swriter s h0 space_beyond sout pout_from0 { swvalue w' == swvalue (w (grvalue r)) } )
= SWriter (Ghost.hide (swvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
swrite (w v) pout_from
)
inline_for_extraction
noextract
let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (writer s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : writer s h0 sout pout_from0 { wvalue w' == wvalue (w (grvalue r)) } )
= Writer (Ghost.hide (wvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
write (w v) pout_from
)
inline_for_extraction
noextract
let owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (owriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : owriter s h0 sout pout_from0 { owvalue w' == owvalue (w (grvalue r))})
= OWriter (Ghost.hide (owvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
owrite (w v) pout_from
)
inline_for_extraction
noextract
let lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (lwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : lwriter s h0 sout pout_from0 { lwvalue w' == lwvalue (w (grvalue r)) } )
= LWriter (Ghost.hide (lwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
lwrite (w v) pout_from
)
inline_for_extraction
noextract
let olwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (olwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Pure (olwriter s h0 sout pout_from0)
(requires True)
(ensures (fun w' -> olwvalue w' == olwvalue (w (grvalue r))))
= OLWriter (Ghost.hide (olwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
olwrite (w v) pout_from
)
inline_for_extraction
noextract
let greader_tot
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(#t: Type)
(x: t)
: Tot (r: greader h0 sout pout_from0 t { grvalue r == x } )
= GReader (Ghost.hide x) (fun _ -> x)
inline_for_extraction
noextract
let graccess
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(#g: gaccessor p1 p2 cl)
(a: accessor g)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k1.parser_kind_subkind == Some ParserStrong /\
k2.parser_kind_subkind == Some ParserStrong /\
valid p1 h0 sin pin /\
cl.clens_cond (contents p1 h0 sin pin) /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p1 h0 sin pin)) (loc_slice_from sout pout_from0)
})
: Tot (r: greader h0 sout pout_from0 U32.t { grvalue r == slice_access h0 g sin pin } )
= GReader (Ghost.hide (slice_access h0 g sin pin)) (fun _ ->
a sin pin
)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: LowParse.Low.Base.leaf_reader p ->
sin: LowParse.Slice.slice rrel rel ->
pin: FStar.UInt32.t ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
pout_from0: FStar.UInt32.t ->
h0:
FStar.Monotonic.HyperStack.mem
{ Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.valid p h0 sin pin /\
LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from_to sin
pin
(LowParse.Low.Base.Spec.get_valid_pos p h0 sin pin))
(LowParse.Slice.loc_slice_from sout pout_from0) }
-> r':
LowParse.Low.Writers.greader h0 sout pout_from0 t
{LowParse.Low.Writers.grvalue r' == LowParse.Low.Base.Spec.contents p h0 sin pin} | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.leaf_reader",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Slice.srel_of_buffer_srel",
"LowStar.Buffer.trivial_preorder",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"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",
"LowParse.Low.Base.Spec.valid",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Slice.loc_slice_from",
"LowParse.Low.Writers.GReader",
"FStar.Ghost.hide",
"LowParse.Low.Base.Spec.contents",
"Prims.unit",
"LowParse.Low.Writers.greader",
"LowParse.Low.Writers.grvalue"
] | [] | false | false | false | false | false | let read_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(r: leaf_reader p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k.parser_kind_subkind == Some ParserStrong /\ valid p h0 sin pin /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p h0 sin pin))
(loc_slice_from sout pout_from0) })
: Tot (r': greader h0 sout pout_from0 t {grvalue r' == contents p h0 sin pin}) =
| GReader (Ghost.hide (contents p h0 sin pin)) (fun _ -> r sin pin) | false |
Spec.SHA3.fst | Spec.SHA3.absorb_next | val absorb_next (s: state) (rateInBytes: size_nat{rateInBytes > 0 /\ rateInBytes <= 200})
: Tot state | val absorb_next (s: state) (rateInBytes: size_nat{rateInBytes > 0 /\ rateInBytes <= 200})
: Tot state | let absorb_next (s:state) (rateInBytes:size_nat{rateInBytes > 0 /\ rateInBytes <= 200}) : Tot state =
let nextBlock = create rateInBytes (u8 0) in
let nextBlock = nextBlock.[rateInBytes - 1] <- u8 0x80 in
let s = loadState rateInBytes nextBlock s in
state_permute s | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 17,
"end_line": 117,
"start_col": 0,
"start_line": 113
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s
let storeState_inner (s:state) (j:size_nat{j < 25}) (block:lbytes 200) : Tot (lbytes 200) =
update_sub block (j * 8) 8 (uint_to_bytes_le #U64 s.[j])
let storeState (rateInBytes:size_nat{rateInBytes <= 200}) (s:state) : Tot (lbytes rateInBytes) =
let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false | s: Spec.SHA3.state -> rateInBytes: Lib.IntTypes.size_nat{rateInBytes > 0 /\ rateInBytes <= 200}
-> Spec.SHA3.state | Prims.Tot | [
"total"
] | [] | [
"Spec.SHA3.state",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Spec.SHA3.state_permute",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA3.loadState",
"Lib.IntTypes.U8",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.upd",
"Prims.op_Subtraction",
"Lib.IntTypes.mk_int",
"Lib.Sequence.index",
"Prims.l_Forall",
"Prims.nat",
"Prims.pow2",
"Prims.l_imp",
"Prims.op_LessThan",
"Prims.op_disEquality",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.op_String_Assignment",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.u8",
"FStar.Seq.Base.create",
"Lib.Sequence.create"
] | [] | false | false | false | false | false | let absorb_next (s: state) (rateInBytes: size_nat{rateInBytes > 0 /\ rateInBytes <= 200})
: Tot state =
| let nextBlock = create rateInBytes (u8 0) in
let nextBlock = nextBlock.[ rateInBytes - 1 ] <- u8 0x80 in
let s = loadState rateInBytes nextBlock s in
state_permute s | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.olwriter_singleton | val olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot
(x:
olwriter s h0 sout pout_from0
{ olwvalue x ==
(match owvalue w with
| None -> None
| Some x -> Some [x]) }) | val olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot
(x:
olwriter s h0 sout pout_from0
{ olwvalue x ==
(match owvalue w with
| None -> None
| Some x -> Some [x]) }) | let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 789,
"start_col": 0,
"start_line": 762
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | w: LowParse.Low.Writers.owriter s h0 sout pout_from0
-> x:
LowParse.Low.Writers.olwriter s h0 sout pout_from0
{ LowParse.Low.Writers.olwvalue x ==
(match LowParse.Low.Writers.owvalue w with
| FStar.Pervasives.Native.None #_ -> FStar.Pervasives.Native.None
| FStar.Pervasives.Native.Some #_ x -> FStar.Pervasives.Native.Some [x]) } | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"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.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.owriter",
"LowParse.Low.Writers.OLWriter",
"FStar.Ghost.hide",
"Prims.list",
"LowParse.Low.Writers.owvalue",
"FStar.Pervasives.Native.None",
"Prims.Cons",
"Prims.Nil",
"Prims.unit",
"FStar.UInt32.lt",
"FStar.UInt32.sub",
"LowParse.Low.ErrorCode.max_uint32",
"FStar.UInt32.__uint_to_t",
"LowParse.Low.Base.Spec.valid_list_cons",
"LowParse.Low.Base.Spec.valid_list_nil",
"FStar.HyperStack.ST.get",
"Prims.bool",
"FStar.Classical.move_requires",
"FStar.Pervasives.Native.uu___is_Some",
"Prims.l_False",
"Prims.nat",
"LowParse.Low.Base.Spec.serialized_list_length",
"LowParse.Low.Base.Spec.serialized_length",
"Prims.squash",
"FStar.Pervasives.pattern",
"LowParse.Low.Base.Spec.serialized_list_length_nil",
"LowParse.Low.Base.Spec.serialized_list_length_cons",
"FStar.Pervasives.Native.__proj__Some__item__v",
"LowParse.Low.Writers.owrite",
"LowParse.Low.Writers.olwriter",
"LowParse.Low.Writers.olwvalue"
] | [] | false | false | false | false | false | let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot
(x:
olwriter s h0 sout pout_from0
{ olwvalue x ==
(match owvalue w with
| None -> None
| Some x -> Some [x]) }) =
| OLWriter
(Ghost.hide (match owvalue w with
| None -> None
| Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
else
([@@ inline_let ]let f ()
: Lemma (requires (Some? (owvalue w)))
(ensures
(match owvalue w with
| None -> False
| Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ());
res) | false |
LowParse.Low.Writers.fst | LowParse.Low.Writers.wjcopy | val wjcopy
(#k #t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0:
HS.mem
{ valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from))
(loc_slice_from sout sout_from0) })
: Tot (w: writer s h0 sout sout_from0 {wvalue w == contents p h0 sin pin_from}) | val wjcopy
(#k #t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0:
HS.mem
{ valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from))
(loc_slice_from sout sout_from0) })
: Tot (w: writer s h0 sout sout_from0 {wvalue w == contents p h0 sin pin_from}) | let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
) | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 899,
"start_col": 0,
"start_line": 879
} | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
s:
LowParse.Spec.Base.serializer p
{ Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } ->
j: LowParse.Low.Base.jumper p ->
sin: LowParse.Slice.slice rrel rel ->
pin_from: FStar.UInt32.t ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
sout_from0: FStar.UInt32.t ->
h0:
FStar.Monotonic.HyperStack.mem
{ LowParse.Low.Base.Spec.valid p h0 sin pin_from /\
LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from_to sin
pin_from
(LowParse.Low.Base.Spec.get_valid_pos p h0 sin pin_from))
(LowParse.Slice.loc_slice_from sout sout_from0) }
-> w:
LowParse.Low.Writers.writer s h0 sout sout_from0
{LowParse.Low.Writers.wvalue w == LowParse.Low.Base.Spec.contents p h0 sin pin_from} | Prims.Tot | [
"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",
"LowParse.Low.Base.jumper",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Slice.srel_of_buffer_srel",
"LowStar.Buffer.trivial_preorder",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Slice.loc_slice_from",
"LowParse.Low.Writers.Writer",
"FStar.Ghost.hide",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.copy_weak",
"LowParse.Low.Writers.writer",
"LowParse.Low.Writers.wvalue"
] | [] | false | false | false | false | false | let wjcopy
(#k #t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0:
HS.mem
{ valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from))
(loc_slice_from sout sout_from0) })
: Tot (w: writer s h0 sout sout_from0 {wvalue w == contents p h0 sin pin_from}) =
| Writer (Ghost.hide (contents p h0 sin pin_from))
(fun sout_from -> copy_weak p j sin pin_from sout sout_from) | false |
Spec.SHA3.fst | Spec.SHA3.keccak | val keccak:
rate:size_nat{rate % 8 == 0 /\ rate / 8 > 0 /\ rate <= 1600}
-> capacity:size_nat{capacity + rate == 1600}
-> inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> delimitedSuffix:byte_t
-> outputByteLen:size_nat ->
Tot (lbytes outputByteLen) | val keccak:
rate:size_nat{rate % 8 == 0 /\ rate / 8 > 0 /\ rate <= 1600}
-> capacity:size_nat{capacity + rate == 1600}
-> inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> delimitedSuffix:byte_t
-> outputByteLen:size_nat ->
Tot (lbytes outputByteLen) | let keccak rate capacity inputByteLen input delimitedSuffix outputByteLen =
let rateInBytes = rate / 8 in
let s = create 25 (u64 0) in
let s = absorb s rateInBytes inputByteLen input delimitedSuffix in
squeeze s rateInBytes outputByteLen | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 37,
"end_line": 200,
"start_col": 0,
"start_line": 196
} | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s
let storeState_inner (s:state) (j:size_nat{j < 25}) (block:lbytes 200) : Tot (lbytes 200) =
update_sub block (j * 8) 8 (uint_to_bytes_le #U64 s.[j])
let storeState (rateInBytes:size_nat{rateInBytes <= 200}) (s:state) : Tot (lbytes rateInBytes) =
let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes
let absorb_next (s:state) (rateInBytes:size_nat{rateInBytes > 0 /\ rateInBytes <= 200}) : Tot state =
let nextBlock = create rateInBytes (u8 0) in
let nextBlock = nextBlock.[rateInBytes - 1] <- u8 0x80 in
let s = loadState rateInBytes nextBlock s in
state_permute s
val absorb_last:
delimitedSuffix:byte_t
-> rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200}
-> rem:size_nat{rem < rateInBytes}
-> input:lbytes rem
-> s:state ->
Tot state
let absorb_last delimitedSuffix rateInBytes rem input s =
let lastBlock = create rateInBytes (u8 0) in
let lastBlock = update_sub lastBlock 0 rem input in
let lastBlock = lastBlock.[rem] <- byte_to_uint8 delimitedSuffix in
let s = loadState rateInBytes lastBlock s in
let s =
if not ((delimitedSuffix &. byte 0x80) =. byte 0) &&
(rem = rateInBytes - 1)
then state_permute s else s in
absorb_next s rateInBytes
let absorb_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block:lbytes rateInBytes)
(s:state) :
Tot state =
let s = loadState rateInBytes block s in
state_permute s
let absorb
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(delimitedSuffix:byte_t) :
Tot state =
repeat_blocks rateInBytes input
(absorb_inner rateInBytes)
(absorb_last delimitedSuffix rateInBytes) s
let squeeze_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat)
(i:size_nat{i < outputByteLen / rateInBytes})
(s:state) :
Tot (state & lbytes rateInBytes) =
let block = storeState rateInBytes s in
let s = state_permute s in
s, block
let squeeze
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat):
Tot (lbytes outputByteLen) =
let outBlocks = outputByteLen / rateInBytes in
let a (i:nat{i <= outBlocks}) = state in
let s, output =
generate_blocks rateInBytes outBlocks outBlocks a
(squeeze_inner rateInBytes outputByteLen) s
in
let remOut = outputByteLen % rateInBytes in
let block = storeState remOut s in
(to_lseq output) @| block
val keccak:
rate:size_nat{rate % 8 == 0 /\ rate / 8 > 0 /\ rate <= 1600}
-> capacity:size_nat{capacity + rate == 1600}
-> inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> delimitedSuffix:byte_t
-> outputByteLen:size_nat ->
Tot (lbytes outputByteLen) | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 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"
} | false |
rate: Lib.IntTypes.size_nat{rate % 8 == 0 /\ rate / 8 > 0 /\ rate <= 1600} ->
capacity: Lib.IntTypes.size_nat{capacity + rate == 1600} ->
inputByteLen: Prims.nat ->
input: Lib.ByteSequence.bytes{Lib.Sequence.length input == inputByteLen} ->
delimitedSuffix: Lib.IntTypes.byte_t ->
outputByteLen: Lib.IntTypes.size_nat
-> Lib.ByteSequence.lbytes outputByteLen | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_Division",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Prims.nat",
"Lib.ByteSequence.bytes",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.IntTypes.byte_t",
"Spec.SHA3.squeeze",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Spec.SHA3.absorb",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.op_LessThan",
"Lib.Sequence.index",
"Lib.Sequence.create",
"Lib.IntTypes.uint64",
"Lib.IntTypes.u64",
"Lib.ByteSequence.lbytes"
] | [] | false | false | false | false | false | let keccak rate capacity inputByteLen input delimitedSuffix outputByteLen =
| let rateInBytes = rate / 8 in
let s = create 25 (u64 0) in
let s = absorb s rateInBytes inputByteLen input delimitedSuffix in
squeeze s rateInBytes outputByteLen | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.